diff --git a/benchmarks/bench_linalg_decompositions.py b/benchmarks/bench_linalg_decompositions.py
index 215742fbd13..eef647d5a8e 100644
--- a/benchmarks/bench_linalg_decompositions.py
+++ b/benchmarks/bench_linalg_decompositions.py
@@ -29,7 +29,7 @@
 # yapf: enable
 
 
-def time_kak_decomposition(target):
+def time_kak_decomposition(target) -> None:
     """Benchmark kak_decomposition
     kak_decomposition is benchmarked because it was historically slow.
     See https://github.com/quantumlib/Cirq/issues/3840 for status of other benchmarks.
diff --git a/benchmarks/circuit_construction.py b/benchmarks/circuit_construction.py
index 6d2b7b34256..fbcc023e44c 100644
--- a/benchmarks/circuit_construction.py
+++ b/benchmarks/circuit_construction.py
@@ -131,6 +131,6 @@ class XOnAllQubitsCircuit:
     params = [[1, 10, 100, 1000], [1, 10, 100, 1000]]
     param_names = ["Number of Qubits(N)", "Depth(D)"]
 
-    def time_circuit_construction(self, N: int, D: int):
+    def time_circuit_construction(self, N: int, D: int) -> cirq.Circuit:
         q = cirq.LineQubit.range(N)
         return cirq.Circuit(cirq.Moment(cirq.X.on_each(*q)) for _ in range(D))
diff --git a/benchmarks/parameter_resolution.py b/benchmarks/parameter_resolution.py
index 17a114d329c..7233919461d 100644
--- a/benchmarks/parameter_resolution.py
+++ b/benchmarks/parameter_resolution.py
@@ -24,7 +24,7 @@ class RabiCalibration:
     params = ([50, 100, 150, 200], [20, 40, 60, 80, 100])
     param_names = ["num_qubits", "num_scan_points"]
 
-    def setup(self, num_qubits: int, _):
+    def setup(self, num_qubits: int, _) -> None:
         qubits = cirq.GridQubit.rect(1, num_qubits)
         self.symbols = {q: sympy.Symbol(f'a_{q}') for q in qubits}
         self.circuit = cirq.Circuit(
@@ -32,7 +32,7 @@ def setup(self, num_qubits: int, _):
         )
         self.qubit_amps = {q: random.uniform(0.48, 0.52) for q in qubits}
 
-    def time_parameter_resolution(self, _, num_scan_points: int):
+    def time_parameter_resolution(self, _, num_scan_points: int) -> None:
         for diff in np.linspace(-0.3, 0.3, num=num_scan_points):
             resolver = {self.symbols[q]: amp + diff for q, amp in self.qubit_amps.items()}
             _ = cirq.resolve_parameters(self.circuit, resolver)
diff --git a/benchmarks/randomized_benchmarking.py b/benchmarks/randomized_benchmarking.py
index 7a9eef8bee1..363a1534951 100644
--- a/benchmarks/randomized_benchmarking.py
+++ b/benchmarks/randomized_benchmarking.py
@@ -39,7 +39,7 @@ class SingleQubitRandomizedBenchmarking:
     param_names = ["depth", "num_qubits", "num_circuits"]
     timeout = 600  # Change timeout to 10 minutes instead of default 60 seconds.
 
-    def setup(self, *_):
+    def setup(self, *_) -> None:
         self.sq_xz_matrices = np.array(
             [
                 dot([cirq.unitary(c) for c in reversed(group)])
@@ -60,12 +60,12 @@ def _get_op_grid(self, qubits: list[cirq.Qid], depth: int) -> list[list[cirq.Ope
             op_grid.append(op_sequence)
         return op_grid
 
-    def time_rb_op_grid_generation(self, depth: int, num_qubits: int, num_circuits: int):
+    def time_rb_op_grid_generation(self, depth: int, num_qubits: int, num_circuits: int) -> None:
         qubits = cirq.GridQubit.rect(1, num_qubits)
         for _ in range(num_circuits):
             self._get_op_grid(qubits, depth)
 
-    def time_rb_circuit_construction(self, depth: int, num_qubits: int, num_circuits: int):
+    def time_rb_circuit_construction(self, depth: int, num_qubits: int, num_circuits: int) -> None:
         qubits = cirq.GridQubit.rect(1, num_qubits)
         for _ in range(num_circuits):
             op_grid = self._get_op_grid(qubits, depth)
diff --git a/benchmarks/serialization.py b/benchmarks/serialization.py
index 4f8984a3b58..55664dbaa5a 100644
--- a/benchmarks/serialization.py
+++ b/benchmarks/serialization.py
@@ -29,7 +29,7 @@ class SerializeLargeExpandedCircuits:
     params = ([100, 500, 1000], [100, 1000, 4000])
     timeout = 600  # Change timeout to 2 minutes instead of default 60 seconds.
 
-    def setup(self, num_qubits: int, num_moments: int):
+    def setup(self, num_qubits: int, num_moments: int) -> None:
         qubits = cirq.LineQubit.range(num_qubits)
         one_q_x_moment = cirq.Moment(cirq.X(q) for q in qubits[::2])
         one_q_y_moment = cirq.Moment(cirq.Y(q) for q in qubits[1::2])
@@ -43,11 +43,11 @@ def setup(self, num_qubits: int, num_moments: int):
             * (num_moments // 5)
         )
 
-    def time_json_serialization(self, *_):
+    def time_json_serialization(self, *_) -> None:
         _ = cirq.to_json(self.circuit)
 
-    def time_json_serialization_gzip(self, *_):
+    def time_json_serialization_gzip(self, *_) -> None:
         _ = cirq.to_json_gzip(self.circuit)
 
-    def track_json_serialization_gzip_size(self, *_):
+    def track_json_serialization_gzip_size(self, *_) -> str:
         return _human_size(len(cirq.to_json_gzip(self.circuit)))
diff --git a/benchmarks/transformers/routing.py b/benchmarks/transformers/routing.py
index d0d9f54a3cb..a24e756682e 100644
--- a/benchmarks/transformers/routing.py
+++ b/benchmarks/transformers/routing.py
@@ -20,7 +20,7 @@ class RouteCQC:
     param_names = ["qubits", "depth", "op_density", "grid_device_size"]
     timeout = 300  # Increase timeout to 5 minutes instead of default 60 seconds.
 
-    def setup(self, qubits: int, depth: int, op_density: float, grid_device_size: int):
+    def setup(self, qubits: int, depth: int, op_density: float, grid_device_size: int) -> None:
         gate_domain = {cirq.CNOT: 2, cirq.X: 1}
         self.circuit = cirq.testing.random_circuit(
             qubits, depth, op_density, gate_domain=gate_domain, random_state=12345
@@ -28,12 +28,12 @@ def setup(self, qubits: int, depth: int, op_density: float, grid_device_size: in
         self.device = cirq.testing.construct_grid_device(grid_device_size, grid_device_size)
         self.router = cirq.RouteCQC(self.device.metadata.nx_graph)
 
-    def time_circuit_routing(self, *_):
+    def time_circuit_routing(self, *_) -> None:
         self.routed_circuit = self.router(self.circuit)
 
     def track_routed_circuit_depth_ratio(self, *_) -> float:
         self.routed_circuit = self.router(self.circuit)
         return len(self.routed_circuit) / len(self.circuit)
 
-    def teardown(self, *_):
+    def teardown(self, *_) -> None:
         self.device.validate_circuit(self.routed_circuit)
diff --git a/benchmarks/transformers/transformer_primitives.py b/benchmarks/transformers/transformer_primitives.py
index 6981d9aa5fd..6a2e549993d 100644
--- a/benchmarks/transformers/transformer_primitives.py
+++ b/benchmarks/transformers/transformer_primitives.py
@@ -20,7 +20,7 @@ class MapLargeExpandedCircuit:
     params = ([100, 500, 1000], [100, 1000, 4000])
     timeout = 600  # Change timeout to 2 minutes instead of default 60 seconds.
 
-    def setup(self, num_qubits: int, num_moments: int):
+    def setup(self, num_qubits: int, num_moments: int) -> None:
         qubits = cirq.LineQubit.range(num_qubits)
         one_q_x_moment = cirq.Moment(cirq.X(q) for q in qubits[::2])
         one_q_y_moment = cirq.Moment(cirq.Y(q) for q in qubits[1::2])
@@ -32,7 +32,7 @@ def setup(self, num_qubits: int, num_moments: int):
             [one_q_x_moment, two_q_cx_moment, one_q_y_moment, two_q_cz_moment] * (num_moments // 4)
         )
 
-    def time_map_moments(self, num_qubits: int, _):
+    def time_map_moments(self, num_qubits: int, _) -> None:
         all_qubits = cirq.LineQubit.range(num_qubits)
 
         def map_func(m: cirq.Moment, _) -> cirq.Moment:
@@ -46,19 +46,19 @@ def map_func(m: cirq.Moment, _) -> cirq.Moment:
 
         _ = cirq.map_moments(circuit=self.circuit, map_func=map_func)
 
-    def time_map_operations_apply_tag(self, *_):
+    def time_map_operations_apply_tag(self, *_) -> None:
         def map_func(op: cirq.Operation, _) -> cirq.Operation:
             return op.with_tags("old op")
 
         _ = cirq.map_operations(circuit=self.circuit, map_func=map_func)
 
-    def time_map_operations_to_optree(self, *_):
+    def time_map_operations_to_optree(self, *_) -> None:
         def map_func(op: cirq.Operation, _) -> cirq.OP_TREE:
             return [op, op]
 
         _ = cirq.map_operations(circuit=self.circuit, map_func=map_func)
 
-    def time_map_operations_to_optree_and_unroll(self, *_):
+    def time_map_operations_to_optree_and_unroll(self, *_) -> None:
         def map_func(op: cirq.Operation, _) -> cirq.OP_TREE:
             return [op, op]
 
diff --git a/cirq-aqt/cirq_aqt/aqt_device.py b/cirq-aqt/cirq_aqt/aqt_device.py
index d1b2357430b..619e5b43979 100644
--- a/cirq-aqt/cirq_aqt/aqt_device.py
+++ b/cirq-aqt/cirq_aqt/aqt_device.py
@@ -189,7 +189,7 @@ def __init__(
         self.noise_dict = noise_dict
         self.simulate_ideal = simulate_ideal
 
-    def generate_circuit_from_list(self, json_string: str):
+    def generate_circuit_from_list(self, json_string: str) -> None:
         """Generates a list of cirq operations from a json string.
 
         The default behavior is to add a measurement to any qubit at the end
@@ -288,11 +288,11 @@ def __init__(
     def metadata(self) -> aqt_device_metadata.AQTDeviceMetadata:
         return self._metadata
 
-    def validate_gate(self, gate: cirq.Gate):
+    def validate_gate(self, gate: cirq.Gate) -> None:
         if gate not in self.metadata.gateset:
             raise ValueError(f'Unsupported gate type: {gate!r}')
 
-    def validate_operation(self, operation):
+    def validate_operation(self, operation) -> None:
         if not isinstance(operation, cirq.GateOperation):
             raise ValueError(f'Unsupported operation: {operation!r}')
 
@@ -304,7 +304,7 @@ def validate_operation(self, operation):
             if q not in self.qubits:
                 raise ValueError(f'Qubit not on device: {q!r}')
 
-    def validate_circuit(self, circuit: cirq.AbstractCircuit):
+    def validate_circuit(self, circuit: cirq.AbstractCircuit) -> None:
         super().validate_circuit(circuit)
         _verify_unique_measurement_keys(circuit.all_operations())
 
diff --git a/cirq-aqt/cirq_aqt/aqt_device_metadata_test.py b/cirq-aqt/cirq_aqt/aqt_device_metadata_test.py
index 007ddf7a8b7..30b40fc9de5 100644
--- a/cirq-aqt/cirq_aqt/aqt_device_metadata_test.py
+++ b/cirq-aqt/cirq_aqt/aqt_device_metadata_test.py
@@ -38,7 +38,7 @@ def metadata(qubits) -> AQTDeviceMetadata:
     )
 
 
-def test_aqtdevice_metadata(metadata, qubits):
+def test_aqtdevice_metadata(metadata, qubits) -> None:
     assert metadata.qubit_set == frozenset(qubits)
     assert set(qubits) == set(metadata.nx_graph.nodes())
     edges = metadata.nx_graph.edges()
@@ -48,7 +48,7 @@ def test_aqtdevice_metadata(metadata, qubits):
     assert len(metadata.gate_durations) == 4
 
 
-def test_aqtdevice_duration_of(metadata, qubits):
+def test_aqtdevice_duration_of(metadata, qubits) -> None:
     q0, q1 = qubits[:2]
     ms = cirq.Duration(millis=1)
     assert metadata.duration_of(cirq.Z(q0)) == 10 * ms
@@ -59,5 +59,5 @@ def test_aqtdevice_duration_of(metadata, qubits):
         metadata.duration_of(cirq.I(q0))
 
 
-def test_repr(metadata):
+def test_repr(metadata) -> None:
     cirq.testing.assert_equivalent_repr(metadata, setup_code='import cirq\nimport cirq_aqt\n')
diff --git a/cirq-aqt/cirq_aqt/aqt_device_test.py b/cirq-aqt/cirq_aqt/aqt_device_test.py
index b397e52de3a..98318fa330b 100644
--- a/cirq-aqt/cirq_aqt/aqt_device_test.py
+++ b/cirq-aqt/cirq_aqt/aqt_device_test.py
@@ -43,11 +43,11 @@ def with_qubits(self, *new_qubits) -> NotImplementedOperation:
         raise NotImplementedError()
 
     @property
-    def qubits(self):
+    def qubits(self) -> tuple[cirq.Qid, ...]:
         raise NotImplementedError()
 
 
-def test_init_qubits(device, qubits):
+def test_init_qubits(device, qubits) -> None:
     ms = cirq.Duration(millis=1)
     assert device.qubits == frozenset(qubits)
     with pytest.raises(TypeError, match="NamedQubit"):
@@ -55,12 +55,12 @@ def test_init_qubits(device, qubits):
             measurement_duration=100 * ms,
             twoq_gates_duration=200 * ms,
             oneq_gates_duration=10 * ms,
-            qubits=[cirq.LineQubit(0), cirq.NamedQubit("a")],
+            qubits=[cirq.LineQubit(0), cirq.NamedQubit("a")],  # type: ignore[list-item]
         )
 
 
 @pytest.mark.parametrize('ms', [cirq.Duration(millis=1), timedelta(milliseconds=1)])
-def test_init_durations(ms, qubits):
+def test_init_durations(ms, qubits) -> None:
     dev = aqt_device.AQTDevice(
         qubits=qubits,
         measurement_duration=100 * ms,
@@ -72,12 +72,12 @@ def test_init_durations(ms, qubits):
     assert dev.metadata.measurement_duration == cirq.Duration(millis=100)
 
 
-def test_metadata(device, qubits):
+def test_metadata(device, qubits) -> None:
     assert isinstance(device.metadata, aqt_device_metadata.AQTDeviceMetadata)
     assert device.metadata.qubit_set == frozenset(qubits)
 
 
-def test_repr(device):
+def test_repr(device) -> None:
     assert repr(device) == (
         "cirq_aqt.aqt_device.AQTDevice("
         "measurement_duration=cirq.Duration(millis=100), "
@@ -89,13 +89,13 @@ def test_repr(device):
     cirq.testing.assert_equivalent_repr(device, setup_code='import cirq\nimport cirq_aqt\n')
 
 
-def test_validate_measurement_non_adjacent_qubits_ok(device):
+def test_validate_measurement_non_adjacent_qubits_ok(device) -> None:
     device.validate_operation(
         cirq.GateOperation(cirq.MeasurementGate(2, 'key'), (cirq.LineQubit(0), cirq.LineQubit(1)))
     )
 
 
-def test_validate_operation_existing_qubits(device):
+def test_validate_operation_existing_qubits(device) -> None:
     device.validate_operation(cirq.GateOperation(cirq.XX, (cirq.LineQubit(0), cirq.LineQubit(1))))
     device.validate_operation(cirq.Z(cirq.LineQubit(0)))
     device.validate_operation(
@@ -114,7 +114,7 @@ def test_validate_operation_existing_qubits(device):
         device.validate_operation(cirq.X(cirq.NamedQubit("q1")))
 
 
-def test_validate_operation_supported_gate(device):
+def test_validate_operation_supported_gate(device) -> None:
     class MyGate(cirq.Gate):
         def num_qubits(self):
             return 1
@@ -128,12 +128,12 @@ def num_qubits(self):
         device.validate_operation(NotImplementedOperation())
 
 
-def test_aqt_device_eq(device):
+def test_aqt_device_eq(device) -> None:
     eq = cirq.testing.EqualsTester()
     eq.make_equality_group(lambda: device)
 
 
-def test_validate_circuit_repeat_measurement_keys(device):
+def test_validate_circuit_repeat_measurement_keys(device) -> None:
     circuit = cirq.Circuit()
     circuit.append(
         [cirq.measure(cirq.LineQubit(0), key='a'), cirq.measure(cirq.LineQubit(1), key='a')]
@@ -143,16 +143,16 @@ def test_validate_circuit_repeat_measurement_keys(device):
         device.validate_circuit(circuit)
 
 
-def test_aqt_device_str(device):
+def test_aqt_device_str(device) -> None:
     assert str(device) == "q(0)───q(1)───q(2)"
 
 
-def test_aqt_device_pretty_repr(device):
+def test_aqt_device_pretty_repr(device) -> None:
     cirq.testing.assert_repr_pretty(device, "q(0)───q(1)───q(2)")
     cirq.testing.assert_repr_pretty(device, "AQTDevice(...)", cycle=True)
 
 
-def test_at(device):
+def test_at(device) -> None:
     assert device.at(-1) is None
     assert device.at(0) == cirq.LineQubit(0)
     assert device.at(2) == cirq.LineQubit(2)
diff --git a/cirq-aqt/cirq_aqt/aqt_sampler_test.py b/cirq-aqt/cirq_aqt/aqt_sampler_test.py
index 1cc377d7792..2946d20cf5b 100644
--- a/cirq-aqt/cirq_aqt/aqt_sampler_test.py
+++ b/cirq-aqt/cirq_aqt/aqt_sampler_test.py
@@ -15,6 +15,7 @@
 from __future__ import annotations
 
 import json
+from typing import Any, Self
 from unittest import mock
 
 import numpy as np
@@ -33,11 +34,11 @@ def __init__(self):
         self.test_dict = {'job': {'job_id': '2131da'}, 'response': {'status': 'queued'}}
         self.counter = 0
 
-    def json(self):
+    def json(self) -> dict[str, Any]:
         self.counter += 1
         return self.test_dict
 
-    def update(self, *args, **kwargs):
+    def update(self, *args, **kwargs) -> Self:
         return self
 
 
@@ -55,7 +56,7 @@ class GetResultNoStatus(GetResultReturn):
     """A put mock class for testing error responses
     This will not return a status in the second call"""
 
-    def update(self, *args, **kwargs):
+    def update(self, *args, **kwargs) -> Self:
         del self.test_dict['response']['status']
         return self
 
@@ -64,14 +65,14 @@ class GetResultErrorSecond(GetResultReturn):
     """A put mock class for testing error responses
     This will return an error on the second put call"""
 
-    def update(self, *args, **kwargs):
+    def update(self, *args, **kwargs) -> Self:
         if self.counter >= 1:
             self.test_dict['response']['status'] = 'error'
         return self
 
 
 class SubmitGoodResponse:
-    def json(self):
+    def json(self) -> dict[str, Any]:
         return {"job": {"job_id": "test_job"}, "response": {"status": "queued"}}
 
 
@@ -79,7 +80,7 @@ class SubmitResultNoID:
     """A put mock class for testing error responses
     This will not return an id at the first call"""
 
-    def json(self):
+    def json(self) -> dict[str, Any]:
         return {"job": {}, "response": {"status": "queued"}}
 
 
@@ -87,7 +88,7 @@ class SubmitResultNoStatus:
     """A put mock class for testing error responses
     This will not return an id at the first call"""
 
-    def json(self):
+    def json(self) -> dict[str, Any]:
         return {"job": {"job_id": "test_job"}, "response": {}}
 
 
@@ -95,11 +96,11 @@ class SubmitResultWithError:
     """A put mock class for testing error responses
     This will not return an id at the first call"""
 
-    def json(self):
+    def json(self) -> dict[str, Any]:
         return {"job": {"job_id": "test_job"}, "response": {"status": "error"}}
 
 
-def test_aqt_sampler_submit_job_error_handling():
+def test_aqt_sampler_submit_job_error_handling() -> None:
     for e_return in [SubmitResultNoID(), SubmitResultNoStatus(), SubmitResultWithError()]:
         with (
             mock.patch('cirq_aqt.aqt_sampler.post', return_value=e_return),
@@ -119,7 +120,7 @@ def test_aqt_sampler_submit_job_error_handling():
                 _results = sampler.run_sweep(circuit, params=sweep, repetitions=repetitions)
 
 
-def test_aqt_sampler_get_result_error_handling():
+def test_aqt_sampler_get_result_error_handling() -> None:
     for e_return in [GetResultError(), GetResultErrorSecond(), GetResultNoStatus()]:
         with (
             mock.patch('cirq_aqt.aqt_sampler.post', return_value=SubmitGoodResponse()),
@@ -141,7 +142,7 @@ def test_aqt_sampler_get_result_error_handling():
                 _results = sampler.run_sweep(circuit, params=sweep, repetitions=repetitions)
 
 
-def test_aqt_sampler_empty_circuit():
+def test_aqt_sampler_empty_circuit() -> None:
     num_points = 10
     max_angle = np.pi
     repetitions = 1000
@@ -155,7 +156,7 @@ def test_aqt_sampler_empty_circuit():
         _results = sampler.run_sweep(circuit, params=sweep, repetitions=repetitions)
 
 
-def test_aqt_sampler():
+def test_aqt_sampler() -> None:
     class ResultReturn:
         def __init__(self):
             self.request_counter = 0
@@ -200,7 +201,7 @@ def on_request(self, *args, **kwargs):
     assert result_method.call_count == 3
 
 
-def test_aqt_sampler_sim():
+def test_aqt_sampler_sim() -> None:
     theta = sympy.Symbol('theta')
     num_points = 10
     max_angle = np.pi
@@ -228,7 +229,7 @@ def test_aqt_sampler_sim():
     assert excited_state_probs[-1] == 0.25
 
 
-def test_aqt_sampler_sim_xtalk():
+def test_aqt_sampler_sim_xtalk() -> None:
     num_points = 10
     max_angle = np.pi
     repetitions = 100
@@ -249,7 +250,7 @@ def test_aqt_sampler_sim_xtalk():
     _results = sampler.run_sweep(circuit, params=sweep, repetitions=repetitions)
 
 
-def test_aqt_sampler_ms():
+def test_aqt_sampler_ms() -> None:
     repetitions = 1000
     num_qubits = 4
     _, qubits = get_aqt_device(num_qubits)
@@ -264,7 +265,7 @@ def test_aqt_sampler_ms():
     assert hist[0] > repetitions / 3
 
 
-def test_aqt_device_wrong_op_str():
+def test_aqt_device_wrong_op_str() -> None:
     circuit = cirq.Circuit()
     q0, q1 = cirq.LineQubit.range(2)
     circuit.append(cirq.CNOT(q0, q1) ** 1.0)
diff --git a/cirq-aqt/cirq_aqt/aqt_simulator_test.py b/cirq-aqt/cirq_aqt/aqt_simulator_test.py
index 65b9be5ed60..0be32795a29 100644
--- a/cirq-aqt/cirq_aqt/aqt_simulator_test.py
+++ b/cirq-aqt/cirq_aqt/aqt_simulator_test.py
@@ -21,13 +21,13 @@
 from cirq_aqt.aqt_device import AQTNoiseModel, get_aqt_device
 
 
-def test_simulator_no_circ():
+def test_simulator_no_circ() -> None:
     with pytest.raises(RuntimeError):
         sim = AQTSimulator(num_qubits=1)
         sim.simulate_samples(1)
 
 
-def test_ms_crosstalk_n_noise():
+def test_ms_crosstalk_n_noise() -> None:
     num_qubits = 4
     noise_mod = AQTNoiseModel()
     _, qubits = get_aqt_device(num_qubits)
diff --git a/cirq-aqt/cirq_aqt/aqt_target_gateset_test.py b/cirq-aqt/cirq_aqt/aqt_target_gateset_test.py
index 3da14886b04..29f8f2cdb38 100644
--- a/cirq-aqt/cirq_aqt/aqt_target_gateset_test.py
+++ b/cirq-aqt/cirq_aqt/aqt_target_gateset_test.py
@@ -51,24 +51,27 @@
         (cirq.ZPowGate(exponent=0.5)(Q).controlled_by(Q2, Q3), False),
     ],
 )
-def test_gateset(op: cirq.Operation, expected: bool):
+def test_gateset(op: cirq.Operation, expected: bool) -> None:
     gs = aqt_target_gateset.AQTTargetGateset()
     assert gs.validate(op) == expected
     assert gs.validate(cirq.Circuit(op)) == expected
 
 
-def test_decompose_single_qubit_operation():
+def test_decompose_single_qubit_operation() -> None:
     gs = aqt_target_gateset.AQTTargetGateset()
     tgoph = gs.decompose_to_target_gateset(cirq.H(Q), 0)
+    assert isinstance(tgoph, list)
     assert len(tgoph) == 2
     assert isinstance(tgoph[0].gate, cirq.Rx)
     assert isinstance(tgoph[1].gate, cirq.Ry)
     tcoph = cirq.CircuitOperation(cirq.FrozenCircuit(cirq.H(Q))).with_tags('tagged')
     tgtcoph = gs.decompose_to_target_gateset(tcoph, 0)
+    assert isinstance(tgtcoph, list)
     assert len(tgtcoph) == 2
     assert isinstance(tgtcoph[0].gate, cirq.Rx)
     assert isinstance(tgtcoph[1].gate, cirq.Ry)
     tgopz = gs.decompose_to_target_gateset(cirq.Z(Q), 0)
+    assert isinstance(tgopz, list)
     assert len(tgopz) == 1
     assert isinstance(tgopz[0].gate, cirq.ZPowGate)
     theta = sympy.Symbol('theta')
@@ -76,9 +79,10 @@ def test_decompose_single_qubit_operation():
     return
 
 
-def test_decompose_two_qubit_operation():
+def test_decompose_two_qubit_operation() -> None:
     gs = aqt_target_gateset.AQTTargetGateset()
     tgopsqrtxx = gs.decompose_to_target_gateset(cirq.XX(Q, Q2) ** 0.5, 0)
+    assert isinstance(tgopsqrtxx, list)
     assert len(tgopsqrtxx) == 1
     assert isinstance(tgopsqrtxx[0].gate, cirq.XXPowGate)
     theta = sympy.Symbol('theta')
@@ -86,6 +90,6 @@ def test_decompose_two_qubit_operation():
     return
 
 
-def test_postprocess_transformers():
+def test_postprocess_transformers() -> None:
     gs = aqt_target_gateset.AQTTargetGateset()
     assert len(gs.postprocess_transformers) == 2
diff --git a/cirq-aqt/cirq_aqt/conftest.py b/cirq-aqt/cirq_aqt/conftest.py
index e0864c6df4c..ba3771239ca 100644
--- a/cirq-aqt/cirq_aqt/conftest.py
+++ b/cirq-aqt/cirq_aqt/conftest.py
@@ -15,5 +15,5 @@
 import os
 
 
-def pytest_configure(config):
+def pytest_configure(config) -> None:
     os.environ['CIRQ_TESTING'] = "true"
diff --git a/cirq-core/cirq/circuits/circuit.py b/cirq-core/cirq/circuits/circuit.py
index fe827126ab4..743fcd970b0 100644
--- a/cirq-core/cirq/circuits/circuit.py
+++ b/cirq-core/cirq/circuits/circuit.py
@@ -807,7 +807,7 @@ def findall_operations_with_gate_type(
             gate_op = cast(ops.GateOperation, op)
             yield index, gate_op, cast(_TGate, gate_op.gate)
 
-    def has_measurements(self):
+    def has_measurements(self) -> bool:
         """Returns whether or not this circuit has measurements.
 
         Returns: True if `cirq.is_measurement(self)` is True otherwise False.
@@ -2446,7 +2446,9 @@ def append(
         """
         self.insert(len(self._moments), moment_or_operation_tree, strategy)
 
-    def clear_operations_touching(self, qubits: Iterable[cirq.Qid], moment_indices: Iterable[int]):
+    def clear_operations_touching(
+        self, qubits: Iterable[cirq.Qid], moment_indices: Iterable[int]
+    ) -> None:
         """Clears operations that are touching given qubits at given moments.
 
         Args:
diff --git a/cirq-core/cirq/circuits/circuit_operation.py b/cirq-core/cirq/circuits/circuit_operation.py
index 1b05a013fc3..fc7d09dd8b1 100644
--- a/cirq-core/cirq/circuits/circuit_operation.py
+++ b/cirq-core/cirq/circuits/circuit_operation.py
@@ -648,7 +648,7 @@ def repeat(
     def __pow__(self, power: IntParam) -> cirq.CircuitOperation:
         return self.repeat(power)
 
-    def _with_key_path_(self, path: tuple[str, ...]):
+    def _with_key_path_(self, path: tuple[str, ...]) -> cirq.CircuitOperation:
         return self.replace(parent_path=path)
 
     def _with_key_path_prefix_(self, prefix: tuple[str, ...]):
@@ -667,7 +667,7 @@ def _with_rescoped_keys_(
         path += self.parent_path
         return self.replace(parent_path=path, extern_keys=bindable_keys)
 
-    def with_key_path(self, path: tuple[str, ...]):
+    def with_key_path(self, path: tuple[str, ...]) -> cirq.CircuitOperation:
         """Alias for `cirq.with_key_path(self, path)`.
 
         Args:
diff --git a/cirq-core/cirq/circuits/circuit_test.py b/cirq-core/cirq/circuits/circuit_test.py
index 7169297cc51..f11145aa324 100644
--- a/cirq-core/cirq/circuits/circuit_test.py
+++ b/cirq-core/cirq/circuits/circuit_test.py
@@ -19,7 +19,7 @@
 import time
 from collections import defaultdict
 from random import randint, random, randrange, sample
-from typing import Iterator
+from typing import Iterator, Sequence
 
 import numpy as np
 import pytest
@@ -55,7 +55,7 @@ class _Foxy(ValidatingTestDevice):
 q0, q1, q2, q3 = cirq.LineQubit.range(4)
 
 
-def test_from_moments():
+def test_from_moments() -> None:
     a, b, c, d = cirq.LineQubit.range(4)
     moment = cirq.Moment(cirq.Z(a), cirq.Z(b))
     subcircuit = cirq.FrozenCircuit.from_moments(cirq.X(c), cirq.Y(d))
@@ -83,15 +83,16 @@ def test_from_moments():
         cirq.Moment(cirq.measure(a, b, key='ab'), cirq.measure(c, d, key='cd')),
     )
     assert circuit[0] is moment
+    assert isinstance(circuit[1].operations[0], cirq.CircuitOperation)
     assert circuit[1].operations[0].circuit is subcircuit
 
 
-def test_alignment():
+def test_alignment() -> None:
     assert repr(cirq.Alignment.LEFT) == 'cirq.Alignment.LEFT'
     assert repr(cirq.Alignment.RIGHT) == 'cirq.Alignment.RIGHT'
 
 
-def test_setitem():
+def test_setitem() -> None:
     circuit = cirq.Circuit([cirq.Moment(), cirq.Moment()])
 
     circuit[1] = cirq.Moment([cirq.X(cirq.LineQubit(0))])
@@ -112,7 +113,7 @@ def test_setitem():
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_equality(circuit_cls):
+def test_equality(circuit_cls) -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
 
@@ -142,7 +143,7 @@ def test_equality(circuit_cls):
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_approx_eq(circuit_cls):
+def test_approx_eq(circuit_cls) -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
 
@@ -171,7 +172,7 @@ def test_approx_eq(circuit_cls):
     )
 
 
-def test_append_single():
+def test_append_single() -> None:
     a = cirq.NamedQubit('a')
 
     c = cirq.Circuit()
@@ -193,7 +194,7 @@ def test_append_single():
     )
 
 
-def test_append_control_key():
+def test_append_control_key() -> None:
     q0, q1, q2 = cirq.LineQubit.range(3)
     c = cirq.Circuit()
     c.append(cirq.measure(q0, key='a'))
@@ -207,7 +208,7 @@ def test_append_control_key():
     assert len(c) == 1
 
 
-def test_append_multiple():
+def test_append_multiple() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
 
@@ -225,7 +226,7 @@ def test_append_multiple():
     assert c == cirq.Circuit([cirq.Moment([cirq.X(a), cirq.X(b)])])
 
 
-def test_append_control_key_subcircuit():
+def test_append_control_key_subcircuit() -> None:
     q0, q1 = cirq.LineQubit.range(2)
 
     c = cirq.Circuit()
@@ -291,7 +292,7 @@ def test_append_control_key_subcircuit():
     assert len(c) == 1
 
 
-def test_measurement_key_paths():
+def test_measurement_key_paths() -> None:
     a = cirq.LineQubit(0)
     circuit1 = cirq.Circuit(cirq.measure(a, key='A'))
     assert cirq.measurement_key_names(circuit1) == {'A'}
@@ -301,7 +302,7 @@ def test_measurement_key_paths():
     assert cirq.measurement_key_names(circuit3) == {'C:B:A'}
 
 
-def test_append_moments():
+def test_append_moments() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
 
@@ -320,7 +321,7 @@ def test_append_moments():
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_add_op_tree(circuit_cls):
+def test_add_op_tree(circuit_cls) -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
 
@@ -337,7 +338,7 @@ def test_add_op_tree(circuit_cls):
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_radd_op_tree(circuit_cls):
+def test_radd_op_tree(circuit_cls) -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
 
@@ -355,6 +356,7 @@ def test_radd_op_tree(circuit_cls):
         _ = 0 + c
 
     # non-empty circuit addition
+    d: cirq.AbstractCircuit
     if circuit_cls == cirq.FrozenCircuit:
         d = cirq.FrozenCircuit(cirq.Y(b))
     else:
@@ -366,7 +368,7 @@ def test_radd_op_tree(circuit_cls):
     )
 
 
-def test_add_iadd_equivalence():
+def test_add_iadd_equivalence() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     iadd_circuit = cirq.Circuit(cirq.X(q0))
     iadd_circuit += cirq.H(q1)
@@ -376,13 +378,13 @@ def test_add_iadd_equivalence():
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_bool(circuit_cls):
+def test_bool(circuit_cls) -> None:
     assert not circuit_cls()
     assert circuit_cls(cirq.X(cirq.NamedQubit('a')))
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_repr(circuit_cls):
+def test_repr(circuit_cls) -> None:
     assert repr(circuit_cls()) == f'cirq.{circuit_cls.__name__}()'
 
     a = cirq.NamedQubit('a')
@@ -407,7 +409,7 @@ def test_repr(circuit_cls):
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_empty_moments(circuit_cls):
+def test_empty_moments(circuit_cls) -> None:
     # 1-qubit test
     op = cirq.X(cirq.NamedQubit('a'))
     op_moment = cirq.Moment([op])
@@ -512,7 +514,7 @@ def test_empty_moments(circuit_cls):
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_symbol_addition_in_gate_exponent(circuit_cls):
+def test_symbol_addition_in_gate_exponent(circuit_cls) -> None:
     # 1-qubit test
     qubit = cirq.NamedQubit('a')
     circuit = circuit_cls(
@@ -558,7 +560,7 @@ def test_symbol_addition_in_gate_exponent(circuit_cls):
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_slice(circuit_cls):
+def test_slice(circuit_cls) -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
     c = circuit_cls(
@@ -583,7 +585,7 @@ def test_slice(circuit_cls):
     assert c[0:2:-1] == circuit_cls()
 
 
-def test_concatenate():
+def test_concatenate() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
 
@@ -616,7 +618,7 @@ def test_concatenate():
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_multiply(circuit_cls):
+def test_multiply(circuit_cls) -> None:
     a = cirq.NamedQubit('a')
 
     c = circuit_cls()
@@ -650,7 +652,7 @@ def test_multiply(circuit_cls):
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_container_methods(circuit_cls):
+def test_container_methods(circuit_cls) -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
     c = circuit_cls(
@@ -672,7 +674,7 @@ def test_container_methods(circuit_cls):
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_bad_index(circuit_cls):
+def test_bad_index(circuit_cls) -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
     c = circuit_cls([cirq.Moment([cirq.H(a), cirq.H(b)])])
@@ -680,7 +682,7 @@ def test_bad_index(circuit_cls):
         _ = c['string']
 
 
-def test_append_strategies():
+def test_append_strategies() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
     stream = [cirq.X(a), cirq.CZ(a, b), cirq.X(b), cirq.X(b), cirq.X(a)]
@@ -720,7 +722,7 @@ def test_append_strategies():
     )
 
 
-def test_insert_op_tree_new():
+def test_insert_op_tree_new() -> None:
     a = cirq.NamedQubit('alice')
     b = cirq.NamedQubit('bob')
     c = cirq.Circuit()
@@ -753,7 +755,7 @@ def test_insert_op_tree_new():
         c.insert(1, cirq.X(a), BAD_INSERT)
 
 
-def test_insert_op_tree_newinline():
+def test_insert_op_tree_newinline() -> None:
     a = cirq.NamedQubit('alice')
     b = cirq.NamedQubit('bob')
     c = cirq.Circuit()
@@ -778,7 +780,7 @@ def test_insert_op_tree_newinline():
     assert c == c2
 
 
-def test_insert_op_tree_inline():
+def test_insert_op_tree_inline() -> None:
     a = cirq.NamedQubit('alice')
     b = cirq.NamedQubit('bob')
     c = cirq.Circuit([cirq.Moment([cirq.H(a)])])
@@ -798,7 +800,7 @@ def test_insert_op_tree_inline():
             assert c.operation_at(qubits[i], actual_index) == op_list[i]
 
 
-def test_insert_op_tree_earliest():
+def test_insert_op_tree_earliest() -> None:
     a = cirq.NamedQubit('alice')
     b = cirq.NamedQubit('bob')
     c = cirq.Circuit([cirq.Moment([cirq.H(a)])])
@@ -815,7 +817,7 @@ def test_insert_op_tree_earliest():
             assert c.operation_at(qubits[i], actual_index[i]) == op_list[i]
 
 
-def test_insert_moment():
+def test_insert_moment() -> None:
     a = cirq.NamedQubit('alice')
     b = cirq.NamedQubit('bob')
     c = cirq.Circuit()
@@ -833,18 +835,18 @@ def test_insert_moment():
         assert c.operation_at(qubit, actual_index) == operation[0]
 
 
-def test_circuit_length_inference():
+def test_circuit_length_inference() -> None:
     # tests that `get_earliest_accommodating_moment_index` properly computes circuit length
     circuit = cirq.Circuit(cirq.X(cirq.q(0)))
-    qubit_indices = {cirq.q(0): 0}
-    mkey_indices = {}
-    ckey_indices = {}
+    qubit_indices: dict[cirq.Qid, int] = {cirq.q(0): 0}
+    mkey_indices: dict[cirq.MeasurementKey, int] = {}
+    ckey_indices: dict[cirq.MeasurementKey, int] = {}
     assert circuits.circuit.get_earliest_accommodating_moment_index(
         cirq.Moment(), qubit_indices, mkey_indices, ckey_indices
     ) == len(circuit)
 
 
-def test_insert_inline_near_start():
+def test_insert_inline_near_start() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
 
@@ -867,7 +869,7 @@ def test_insert_inline_near_start():
     )
 
 
-def test_insert_at_frontier_init():
+def test_insert_at_frontier_init() -> None:
     x = cirq.NamedQubit('x')
     op = cirq.X(x)
     circuit = cirq.Circuit(op)
@@ -882,11 +884,11 @@ def test_insert_at_frontier_init():
 
     with pytest.raises(ValueError):
         circuit = cirq.Circuit([cirq.Moment(), cirq.Moment([op])])
-        frontier = {x: 2}
+        frontier: dict[cirq.Qid, int] = {x: 2}
         circuit.insert_at_frontier(op, 0, frontier)
 
 
-def test_insert_at_frontier():
+def test_insert_at_frontier() -> None:
     class Replacer(cirq.PointOptimizer):
         def __init__(self, replacer=(lambda x: x)):
             super().__init__()
@@ -991,7 +993,7 @@ def optimization_at(
     )
 
 
-def test_insert_into_range():
+def test_insert_into_range() -> None:
     x = cirq.NamedQubit('x')
     y = cirq.NamedQubit('y')
     c = cirq.Circuit([cirq.Moment([cirq.X(x)])] * 4)
@@ -1040,7 +1042,7 @@ def test_insert_into_range():
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_next_moment_operating_on(circuit_cls):
+def test_next_moment_operating_on(circuit_cls) -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
 
@@ -1080,7 +1082,7 @@ def test_next_moment_operating_on(circuit_cls):
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_next_moment_operating_on_distance(circuit_cls):
+def test_next_moment_operating_on_distance(circuit_cls) -> None:
     a = cirq.NamedQubit('a')
 
     c = circuit_cls(
@@ -1119,7 +1121,7 @@ def test_next_moment_operating_on_distance(circuit_cls):
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_prev_moment_operating_on(circuit_cls):
+def test_prev_moment_operating_on(circuit_cls) -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
 
@@ -1162,7 +1164,7 @@ def test_prev_moment_operating_on(circuit_cls):
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_prev_moment_operating_on_distance(circuit_cls):
+def test_prev_moment_operating_on_distance(circuit_cls) -> None:
     a = cirq.NamedQubit('a')
 
     c = circuit_cls(
@@ -1202,7 +1204,7 @@ def test_prev_moment_operating_on_distance(circuit_cls):
         c.prev_moment_operating_on([a], 6, max_distance=-1)
 
 
-def test_earliest_available_moment():
+def test_earliest_available_moment() -> None:
     q = cirq.LineQubit.range(3)
     c = cirq.Circuit(
         cirq.Moment(cirq.measure(q[0], key="m")),
@@ -1225,7 +1227,7 @@ def test_earliest_available_moment():
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_operation_at(circuit_cls):
+def test_operation_at(circuit_cls) -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
 
@@ -1248,7 +1250,7 @@ def test_operation_at(circuit_cls):
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_findall_operations(circuit_cls):
+def test_findall_operations(circuit_cls) -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
 
@@ -1292,7 +1294,7 @@ def is_x(op: cirq.Operation) -> bool:
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_findall_operations_with_gate(circuit_cls):
+def test_findall_operations_with_gate(circuit_cls) -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
     c = circuit_cls(
@@ -1320,7 +1322,7 @@ def test_findall_operations_with_gate(circuit_cls):
 
 def assert_findall_operations_until_blocked_as_expected(
     circuit=None, start_frontier=None, is_blocker=None, expected_ops=None
-):
+) -> None:
     if circuit is None:
         circuit = cirq.Circuit()
     if start_frontier is None:
@@ -1338,7 +1340,7 @@ def assert_findall_operations_until_blocked_as_expected(
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_findall_operations_until_blocked(circuit_cls):
+def test_findall_operations_until_blocked(circuit_cls) -> None:
     a, b, c, d = cirq.LineQubit.range(4)
 
     assert_findall_operations_until_blocked_as_expected()
@@ -1505,7 +1507,7 @@ def test_findall_operations_until_blocked(circuit_cls):
 
 @pytest.mark.parametrize('seed', [randint(0, 2**31)])
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_findall_operations_until_blocked_docstring_examples(seed, circuit_cls):
+def test_findall_operations_until_blocked_docstring_examples(seed, circuit_cls) -> None:
     prng = np.random.RandomState(seed)
 
     class ExampleGate(cirq.Gate):
@@ -1618,7 +1620,7 @@ def is_blocker(op):
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_has_measurements(circuit_cls):
+def test_has_measurements(circuit_cls) -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
 
@@ -1663,7 +1665,7 @@ def test_has_measurements(circuit_cls):
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_are_all_or_any_measurements_terminal(circuit_cls):
+def test_are_all_or_any_measurements_terminal(circuit_cls) -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
 
@@ -1719,7 +1721,7 @@ def test_are_all_or_any_measurements_terminal(circuit_cls):
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_all_or_any_terminal(circuit_cls):
+def test_all_or_any_terminal(circuit_cls) -> None:
     def is_x_pow_gate(op):
         return isinstance(op.gate, cirq.XPowGate)
 
@@ -1787,7 +1789,7 @@ def is_circuit_op(op):
     assert not c.are_any_matches_terminal(is_circuit_op)
 
 
-def test_clear_operations_touching():
+def test_clear_operations_touching() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
 
@@ -1849,7 +1851,7 @@ def test_clear_operations_touching():
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_all_qubits(circuit_cls):
+def test_all_qubits(circuit_cls) -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
 
@@ -1867,7 +1869,7 @@ def test_all_qubits(circuit_cls):
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_all_operations(circuit_cls):
+def test_all_operations(circuit_cls) -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
 
@@ -1901,7 +1903,7 @@ def test_all_operations(circuit_cls):
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_qid_shape_qubit(circuit_cls):
+def test_qid_shape_qubit(circuit_cls) -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
     c = cirq.NamedQubit('c')
@@ -1917,7 +1919,7 @@ def test_qid_shape_qubit(circuit_cls):
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_qid_shape_qudit(circuit_cls):
+def test_qid_shape_qudit(circuit_cls) -> None:
     class PlusOneMod3Gate(cirq.testing.SingleQubitGate):
         def _qid_shape_(self):
             return (3,)
@@ -1943,7 +1945,7 @@ def _qid_shape_(self):
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_to_text_diagram_teleportation_to_diagram(circuit_cls):
+def test_to_text_diagram_teleportation_to_diagram(circuit_cls) -> None:
     ali = cirq.NamedQubit('(0, 0)')
     bob = cirq.NamedQubit('(0, 1)')
     msg = cirq.NamedQubit('(1, 0)')
@@ -2020,7 +2022,7 @@ def test_to_text_diagram_teleportation_to_diagram(circuit_cls):
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_diagram_with_unknown_exponent(circuit_cls):
+def test_diagram_with_unknown_exponent(circuit_cls) -> None:
     class WeirdGate(cirq.testing.SingleQubitGate):
         def _circuit_diagram_info_(
             self, args: cirq.CircuitDiagramInfoArgs
@@ -2040,7 +2042,7 @@ def _circuit_diagram_info_(
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_circuit_diagram_on_gate_without_info(circuit_cls):
+def test_circuit_diagram_on_gate_without_info(circuit_cls) -> None:
     q = cirq.NamedQubit('(0, 0)')
     q2 = cirq.NamedQubit('(0, 1)')
     q3 = cirq.NamedQubit('(0, 2)')
@@ -2081,7 +2083,7 @@ def __repr__(self):
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_to_text_diagram_multi_qubit_gate(circuit_cls):
+def test_to_text_diagram_multi_qubit_gate(circuit_cls) -> None:
     q1 = cirq.NamedQubit('(0, 0)')
     q2 = cirq.NamedQubit('(0, 1)')
     q3 = cirq.NamedQubit('(0, 2)')
@@ -2120,7 +2122,7 @@ def test_to_text_diagram_multi_qubit_gate(circuit_cls):
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_to_text_diagram_many_qubits_gate_but_multiple_wire_symbols(circuit_cls):
+def test_to_text_diagram_many_qubits_gate_but_multiple_wire_symbols(circuit_cls) -> None:
     class BadGate(cirq.testing.ThreeQubitGate):
         def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> tuple[str, str]:
             return 'a', 'a'
@@ -2134,7 +2136,7 @@ def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> tuple[str
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_to_text_diagram_parameterized_value(circuit_cls):
+def test_to_text_diagram_parameterized_value(circuit_cls) -> None:
     q = cirq.NamedQubit('cube')
 
     class PGate(cirq.testing.SingleQubitGate):
@@ -2156,7 +2158,7 @@ def _circuit_diagram_info_(
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_to_text_diagram_custom_order(circuit_cls):
+def test_to_text_diagram_custom_order(circuit_cls) -> None:
     qa = cirq.NamedQubit('2')
     qb = cirq.NamedQubit('3')
     qc = cirq.NamedQubit('4')
@@ -2177,7 +2179,7 @@ def test_to_text_diagram_custom_order(circuit_cls):
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_overly_precise_diagram(circuit_cls):
+def test_overly_precise_diagram(circuit_cls) -> None:
     # Test default precision of 3
     qa = cirq.NamedQubit('a')
     c = circuit_cls([cirq.Moment([cirq.X(qa) ** 0.12345678])])
@@ -2191,7 +2193,7 @@ def test_overly_precise_diagram(circuit_cls):
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_none_precision_diagram(circuit_cls):
+def test_none_precision_diagram(circuit_cls) -> None:
     # Test default precision of 3
     qa = cirq.NamedQubit('a')
     c = circuit_cls([cirq.Moment([cirq.X(qa) ** 0.4921875])])
@@ -2206,7 +2208,7 @@ def test_none_precision_diagram(circuit_cls):
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_diagram_custom_precision(circuit_cls):
+def test_diagram_custom_precision(circuit_cls) -> None:
     qa = cirq.NamedQubit('a')
     c = circuit_cls([cirq.Moment([cirq.X(qa) ** 0.12341234])])
     cirq.testing.assert_has_diagram(
@@ -2220,7 +2222,7 @@ def test_diagram_custom_precision(circuit_cls):
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_diagram_wgate(circuit_cls):
+def test_diagram_wgate(circuit_cls) -> None:
     qa = cirq.NamedQubit('a')
     test_wgate = cirq.PhasedXPowGate(exponent=0.12341234, phase_exponent=0.43214321)
     c = circuit_cls([cirq.Moment([test_wgate.on(qa)])])
@@ -2235,7 +2237,7 @@ def test_diagram_wgate(circuit_cls):
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_diagram_wgate_none_precision(circuit_cls):
+def test_diagram_wgate_none_precision(circuit_cls) -> None:
     qa = cirq.NamedQubit('a')
     test_wgate = cirq.PhasedXPowGate(exponent=0.12341234, phase_exponent=0.43214321)
     c = circuit_cls([cirq.Moment([test_wgate.on(qa)])])
@@ -2250,7 +2252,7 @@ def test_diagram_wgate_none_precision(circuit_cls):
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_diagram_global_phase(circuit_cls):
+def test_diagram_global_phase(circuit_cls) -> None:
     qa = cirq.NamedQubit('a')
     global_phase = cirq.global_phase_operation(coefficient=1j)
     c = circuit_cls([global_phase])
@@ -2299,7 +2301,7 @@ def test_diagram_global_phase(circuit_cls):
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_has_unitary(circuit_cls):
+def test_has_unitary(circuit_cls) -> None:
     class NonUnitary(cirq.testing.SingleQubitGate):
         pass
 
@@ -2322,7 +2324,7 @@ def _decompose_(self, qubits):
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_text_diagram_jupyter(circuit_cls):
+def test_text_diagram_jupyter(circuit_cls) -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
     c = cirq.NamedQubit('c')
@@ -2353,7 +2355,7 @@ def text(self, to_print):
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_circuit_to_unitary_matrix(circuit_cls):
+def test_circuit_to_unitary_matrix(circuit_cls) -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
 
@@ -2477,7 +2479,7 @@ class MysteryGate(cirq.testing.TwoQubitGate):
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_circuit_unitary(circuit_cls):
+def test_circuit_unitary(circuit_cls) -> None:
     q = cirq.NamedQubit('q')
 
     with_inner_measure = circuit_cls(cirq.H(q), cirq.measure(q), cirq.H(q))
@@ -2485,14 +2487,14 @@ def test_circuit_unitary(circuit_cls):
     assert cirq.unitary(with_inner_measure, None) is None
 
     cirq.testing.assert_allclose_up_to_global_phase(
-        cirq.unitary(circuit_cls(cirq.X(q) ** 0.5), cirq.measure(q)),
+        cirq.unitary(circuit_cls(cirq.X(q) ** 0.5, cirq.measure(q))),
         np.array([[1j, 1], [1, 1j]]) * np.sqrt(0.5),
         atol=1e-8,
     )
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_simple_circuits_to_unitary_matrix(circuit_cls):
+def test_simple_circuits_to_unitary_matrix(circuit_cls) -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
 
@@ -2528,7 +2530,7 @@ def _unitary_(self) -> np.ndarray:
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_composite_gate_to_unitary_matrix(circuit_cls):
+def test_composite_gate_to_unitary_matrix(circuit_cls) -> None:
     class CnotComposite(cirq.testing.TwoQubitGate):
         def _decompose_(self, qubits):
             q0, q1 = qubits
@@ -2547,7 +2549,7 @@ def _decompose_(self, qubits):
     cirq.testing.assert_allclose_up_to_global_phase(mat, mat_expected, atol=1e-8)
 
 
-def test_circuit_superoperator_too_many_qubits():
+def test_circuit_superoperator_too_many_qubits() -> None:
     circuit = cirq.Circuit(cirq.IdentityGate(num_qubits=11).on(*cirq.LineQubit.range(11)))
     assert not circuit._has_superoperator_()
     with pytest.raises(ValueError, match="too many"):
@@ -2597,7 +2599,7 @@ def test_circuit_superoperator_too_many_qubits():
         ),
     ),
 )
-def test_circuit_superoperator_fixed_values(circuit, expected_superoperator):
+def test_circuit_superoperator_fixed_values(circuit, expected_superoperator) -> None:
     """Tests Circuit._superoperator_() on a few simple circuits."""
     assert circuit._has_superoperator_()
     assert np.allclose(circuit._superoperator_(), expected_superoperator)
@@ -2615,7 +2617,7 @@ def test_circuit_superoperator_fixed_values(circuit, expected_superoperator):
         ([0.1, 0.2, 0.3], 3),
     ),
 )
-def test_circuit_superoperator_depolarizing_channel_compositions(rs, n_qubits):
+def test_circuit_superoperator_depolarizing_channel_compositions(rs, n_qubits) -> None:
     """Tests Circuit._superoperator_() on compositions of depolarizing channels."""
 
     def pauli_error_probability(r: float, n_qubits: int) -> float:
@@ -2701,7 +2703,7 @@ def density_operator_basis(n_qubits: int) -> Iterator[np.ndarray]:
         ),
     ),
 )
-def test_compare_circuits_superoperator_to_simulation(circuit, initial_state):
+def test_compare_circuits_superoperator_to_simulation(circuit, initial_state) -> None:
     """Compares action of circuit superoperator and circuit simulation."""
     assert circuit._has_superoperator_()
     superoperator = circuit._superoperator_()
@@ -2716,7 +2718,7 @@ def test_compare_circuits_superoperator_to_simulation(circuit, initial_state):
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_expanding_gate_symbols(circuit_cls):
+def test_expanding_gate_symbols(circuit_cls) -> None:
     class MultiTargetCZ(cirq.Gate):
         def __init__(self, num_qubits):
             self._num_qubits = num_qubits
@@ -2764,7 +2766,7 @@ def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> tuple[str
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_transposed_diagram_exponent_order(circuit_cls):
+def test_transposed_diagram_exponent_order(circuit_cls) -> None:
     a, b, c = cirq.LineQubit.range(3)
     circuit = circuit_cls(cirq.CZ(a, b) ** -0.5, cirq.CZ(a, c) ** 0.5, cirq.CZ(b, c) ** 0.125)
     cirq.testing.assert_has_diagram(
@@ -2784,7 +2786,7 @@ def test_transposed_diagram_exponent_order(circuit_cls):
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_transposed_diagram_can_depend_on_transpose(circuit_cls):
+def test_transposed_diagram_can_depend_on_transpose(circuit_cls) -> None:
     class TestGate(cirq.Gate):
         def num_qubits(self):
             return 1
@@ -2807,7 +2809,7 @@ def _circuit_diagram_info_(self, args):
     )
 
 
-def test_insert_moments():
+def test_insert_moments() -> None:
     q = cirq.NamedQubit('q')
     c = cirq.Circuit()
 
@@ -2831,7 +2833,7 @@ def test_insert_moments():
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_final_state_vector(circuit_cls):
+def test_final_state_vector(circuit_cls) -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
 
@@ -3003,7 +3005,7 @@ def test_final_state_vector(circuit_cls):
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
 @pytest.mark.parametrize('resolve_fn', [cirq.resolve_parameters, cirq.resolve_parameters_once])
-def test_is_parameterized(circuit_cls, resolve_fn):
+def test_is_parameterized(circuit_cls, resolve_fn) -> None:
     a, b = cirq.LineQubit.range(2)
     circuit = circuit_cls(
         cirq.CZ(a, b) ** sympy.Symbol('u'),
@@ -3021,7 +3023,7 @@ def test_is_parameterized(circuit_cls, resolve_fn):
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
 @pytest.mark.parametrize('resolve_fn', [cirq.resolve_parameters, cirq.resolve_parameters_once])
-def test_resolve_parameters(circuit_cls, resolve_fn):
+def test_resolve_parameters(circuit_cls, resolve_fn) -> None:
     a, b = cirq.LineQubit.range(2)
     circuit = circuit_cls(
         cirq.CZ(a, b) ** sympy.Symbol('u'),
@@ -3051,7 +3053,7 @@ def test_resolve_parameters(circuit_cls, resolve_fn):
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
 @pytest.mark.parametrize('resolve_fn', [cirq.resolve_parameters, cirq.resolve_parameters_once])
-def test_resolve_parameters_no_change(circuit_cls, resolve_fn):
+def test_resolve_parameters_no_change(circuit_cls, resolve_fn) -> None:
     a, b = cirq.LineQubit.range(2)
     circuit = circuit_cls(cirq.CZ(a, b), cirq.X(a), cirq.Y(b))
     resolved_circuit = resolve_fn(circuit, cirq.ParamResolver({'u': 0.1, 'v': 0.3, 'w': 0.2}))
@@ -3068,7 +3070,7 @@ def test_resolve_parameters_no_change(circuit_cls, resolve_fn):
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
 @pytest.mark.parametrize('resolve_fn', [cirq.resolve_parameters, cirq.resolve_parameters_once])
-def test_parameter_names(circuit_cls, resolve_fn):
+def test_parameter_names(circuit_cls, resolve_fn) -> None:
     a, b = cirq.LineQubit.range(2)
     circuit = circuit_cls(
         cirq.CZ(a, b) ** sympy.Symbol('u'),
@@ -3080,7 +3082,7 @@ def test_parameter_names(circuit_cls, resolve_fn):
     assert cirq.parameter_names(resolved_circuit) == set()
 
 
-def test_items():
+def test_items() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
     c = cirq.Circuit()
@@ -3108,12 +3110,12 @@ def test_items():
     cirq.testing.assert_same_circuits(c, cirq.Circuit([m1]))
 
     with pytest.raises(TypeError):
-        c[:] = [m1, 1]
+        c[:] = [m1, 1]  # type: ignore
     with pytest.raises(TypeError):
-        c[0] = 1
+        c[0] = 1  # type: ignore[call-overload]
 
 
-def test_copy():
+def test_copy() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
     c = cirq.Circuit(cirq.X(a), cirq.CZ(a, b), cirq.Z(a), cirq.Z(b))
@@ -3124,7 +3126,7 @@ def test_copy():
     assert c2 != c
 
 
-def test_batch_remove():
+def test_batch_remove() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
     original = cirq.Circuit(
@@ -3203,7 +3205,7 @@ def test_batch_remove():
     assert after == original
 
 
-def test_batch_replace():
+def test_batch_replace() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
     original = cirq.Circuit(
@@ -3257,7 +3259,7 @@ def test_batch_replace():
     )
 
 
-def test_batch_insert_into():
+def test_batch_insert_into() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
     c = cirq.NamedQubit('c')
@@ -3360,7 +3362,7 @@ def test_batch_insert_into():
     assert after == original
 
 
-def test_batch_insert():
+def test_batch_insert() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
     original = cirq.Circuit(
@@ -3392,7 +3394,7 @@ def test_batch_insert():
     )
 
 
-def test_batch_insert_multiple_same_index():
+def test_batch_insert_multiple_same_index() -> None:
     a, b = cirq.LineQubit.range(2)
     c = cirq.Circuit()
     c.batch_insert([(0, cirq.Z(a)), (0, cirq.Z(b)), (0, cirq.Z(a))])
@@ -3401,21 +3403,21 @@ def test_batch_insert_multiple_same_index():
     )
 
 
-def test_batch_insert_reverses_order_for_same_index_inserts():
+def test_batch_insert_reverses_order_for_same_index_inserts() -> None:
     a, b = cirq.LineQubit.range(2)
     c = cirq.Circuit()
     c.batch_insert([(0, cirq.Z(a)), (0, cirq.CZ(a, b)), (0, cirq.Z(b))])
     assert c == cirq.Circuit(cirq.Z(b), cirq.CZ(a, b), cirq.Z(a))
 
 
-def test_batch_insert_maintains_order_despite_multiple_previous_inserts():
+def test_batch_insert_maintains_order_despite_multiple_previous_inserts() -> None:
     a, b = cirq.LineQubit.range(2)
     c = cirq.Circuit(cirq.H(a))
     c.batch_insert([(0, cirq.Z(a)), (0, cirq.Z(a)), (0, cirq.Z(a)), (1, cirq.CZ(a, b))])
     assert c == cirq.Circuit([cirq.Z(a)] * 3, cirq.H(a), cirq.CZ(a, b))
 
 
-def test_batch_insert_doesnt_overshift_due_to_previous_shifts():
+def test_batch_insert_doesnt_overshift_due_to_previous_shifts() -> None:
     a = cirq.NamedQubit('a')
     c = cirq.Circuit([cirq.H(a)] * 3)
     c.batch_insert([(0, cirq.Z(a)), (0, cirq.Z(a)), (1, cirq.X(a)), (2, cirq.Y(a))])
@@ -3424,7 +3426,7 @@ def test_batch_insert_doesnt_overshift_due_to_previous_shifts():
     )
 
 
-def test_batch_insert_doesnt_overshift_due_to_inline_inserts():
+def test_batch_insert_doesnt_overshift_due_to_inline_inserts() -> None:
     a, b = cirq.LineQubit.range(2)
     c = cirq.Circuit(cirq.SWAP(a, b), cirq.SWAP(a, b), cirq.H(a), cirq.SWAP(a, b), cirq.SWAP(a, b))
     c.batch_insert([(0, cirq.X(a)), (3, cirq.X(b)), (4, cirq.Y(a))])
@@ -3441,7 +3443,7 @@ def test_batch_insert_doesnt_overshift_due_to_inline_inserts():
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_next_moments_operating_on(circuit_cls):
+def test_next_moments_operating_on(circuit_cls) -> None:
     for _ in range(20):
         n_moments = randint(1, 10)
         circuit = cirq.testing.random_circuit(randint(1, 20), n_moments, random())
@@ -3458,7 +3460,7 @@ def test_next_moments_operating_on(circuit_cls):
             assert (not p) or (p < start)
 
 
-def test_pick_inserted_ops_moment_indices():
+def test_pick_inserted_ops_moment_indices() -> None:
     for _ in range(20):
         n_moments = randint(1, 10)
         n_qubits = randint(1, 20)
@@ -3484,7 +3486,7 @@ def test_pick_inserted_ops_moment_indices():
         assert actual_circuit == expected_circuit
 
 
-def test_push_frontier_new_moments():
+def test_push_frontier_new_moments() -> None:
     operation = cirq.X(cirq.NamedQubit('q'))
     insertion_index = 3
     circuit = cirq.Circuit()
@@ -3494,7 +3496,7 @@ def test_push_frontier_new_moments():
     )
 
 
-def test_push_frontier_random_circuit():
+def test_push_frontier_random_circuit() -> None:
     for _ in range(20):
         n_moments = randint(1, 10)
         circuit = cirq.testing.random_circuit(randint(1, 20), n_moments, random())
@@ -3529,7 +3531,7 @@ def test_push_frontier_random_circuit():
 @pytest.mark.parametrize(
     'circuit', [cirq.testing.random_circuit(cirq.LineQubit.range(10), 10, 0.5) for _ in range(20)]
 )
-def test_insert_operations_random_circuits(circuit):
+def test_insert_operations_random_circuits(circuit) -> None:
     n_moments = len(circuit)
     operations, insert_indices = [], []
     for moment_index, moment in enumerate(circuit):
@@ -3541,7 +3543,7 @@ def test_insert_operations_random_circuits(circuit):
     assert circuit == other_circuit
 
 
-def test_insert_zero_index():
+def test_insert_zero_index() -> None:
     # Should always go to moment[0], independent of qubit order or earliest/inline strategy.
     q0, q1 = cirq.LineQubit.range(2)
     c0 = cirq.Circuit(cirq.X(q0))
@@ -3559,7 +3561,7 @@ def test_insert_zero_index():
     assert c3 == expected
 
 
-def test_insert_earliest_on_previous_moment():
+def test_insert_earliest_on_previous_moment() -> None:
     q = cirq.LineQubit(0)
     c = cirq.Circuit(cirq.Moment(cirq.X(q)), cirq.Moment(), cirq.Moment(), cirq.Moment(cirq.Z(q)))
     c.insert(3, cirq.Y(q), strategy=cirq.InsertStrategy.EARLIEST)
@@ -3569,7 +3571,7 @@ def test_insert_earliest_on_previous_moment():
     )
 
 
-def test_insert_inline_end_of_circuit():
+def test_insert_inline_end_of_circuit() -> None:
     # If end index is specified, INLINE should place all ops there independent of qubit order.
     q0, q1 = cirq.LineQubit.range(2)
     c0 = cirq.Circuit(cirq.X(q0))
@@ -3587,7 +3589,7 @@ def test_insert_inline_end_of_circuit():
     assert c3 == expected
 
 
-def test_insert_operations_errors():
+def test_insert_operations_errors() -> None:
     a, b, c = (cirq.NamedQubit(s) for s in 'abc')
     with pytest.raises(ValueError):
         circuit = cirq.Circuit([cirq.Moment([cirq.Z(c)])])
@@ -3609,7 +3611,7 @@ def test_insert_operations_errors():
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_to_qasm(circuit_cls):
+def test_to_qasm(circuit_cls) -> None:
     q0 = cirq.NamedQubit('q0')
     circuit = circuit_cls(cirq.X(q0), cirq.measure(q0, key='mmm'))
     assert circuit.to_qasm() == cirq.qasm(circuit)
@@ -3651,7 +3653,7 @@ def test_to_qasm(circuit_cls):
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_save_qasm(tmpdir, circuit_cls):
+def test_save_qasm(tmpdir, circuit_cls) -> None:
     file_path = os.path.join(tmpdir, 'test.qasm')
     q0 = cirq.NamedQubit('q0')
     circuit = circuit_cls(cirq.X(q0))
@@ -3677,7 +3679,7 @@ def test_save_qasm(tmpdir, circuit_cls):
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_findall_operations_between(circuit_cls):
+def test_findall_operations_between(circuit_cls) -> None:
     a, b, c, d = cirq.LineQubit.range(4)
 
     #    0: ───H───@───────────────────────────────────────@───H───
@@ -3757,7 +3759,7 @@ def test_findall_operations_between(circuit_cls):
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_reachable_frontier_from(circuit_cls):
+def test_reachable_frontier_from(circuit_cls) -> None:
     a, b, c, d = cirq.LineQubit.range(4)
 
     #    0: ───H───@───────────────────────────────────────@───H───
@@ -3827,7 +3829,7 @@ def test_reachable_frontier_from(circuit_cls):
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_submoments(circuit_cls):
+def test_submoments(circuit_cls) -> None:
     a, b, c, d, e, f = cirq.LineQubit.range(6)
     circuit = circuit_cls(
         cirq.H.on(a),
@@ -3927,7 +3929,7 @@ def test_submoments(circuit_cls):
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_decompose(circuit_cls):
+def test_decompose(circuit_cls) -> None:
     a, b = cirq.LineQubit.range(2)
     assert cirq.decompose(circuit_cls(cirq.X(a), cirq.Y(b), cirq.CZ(a, b))) == [
         cirq.X(a),
@@ -3937,7 +3939,7 @@ def test_decompose(circuit_cls):
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_measurement_key_mapping(circuit_cls):
+def test_measurement_key_mapping(circuit_cls) -> None:
     a, b = cirq.LineQubit.range(2)
     c = circuit_cls(cirq.X(a), cirq.measure(a, key='m1'), cirq.measure(b, key='m2'))
     assert c.all_measurement_key_names() == {'m1', 'm2'}
@@ -3966,7 +3968,7 @@ def test_measurement_key_mapping(circuit_cls):
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_measurement_key_mapping_preserves_moments(circuit_cls):
+def test_measurement_key_mapping_preserves_moments(circuit_cls) -> None:
     a, b = cirq.LineQubit.range(2)
     c = circuit_cls(
         cirq.Moment(cirq.X(a)),
@@ -3983,7 +3985,7 @@ def test_measurement_key_mapping_preserves_moments(circuit_cls):
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_inverse(circuit_cls):
+def test_inverse(circuit_cls) -> None:
     a, b = cirq.LineQubit.range(2)
     forward = circuit_cls((cirq.X**0.5)(a), (cirq.Y**-0.2)(b), cirq.CZ(a, b))
     backward = circuit_cls((cirq.CZ ** (-1.0))(a, b), (cirq.X ** (-0.5))(a), (cirq.Y ** (0.2))(b))
@@ -4002,7 +4004,7 @@ def test_inverse(circuit_cls):
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_pow_valid_only_for_minus_1(circuit_cls):
+def test_pow_valid_only_for_minus_1(circuit_cls) -> None:
     a, b = cirq.LineQubit.range(2)
     forward = circuit_cls((cirq.X**0.5)(a), (cirq.Y**-0.2)(b), cirq.CZ(a, b))
 
@@ -4017,7 +4019,7 @@ def test_pow_valid_only_for_minus_1(circuit_cls):
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_moment_groups(circuit_cls):
+def test_moment_groups(circuit_cls) -> None:
     qubits = [cirq.GridQubit(x, y) for x in range(8) for y in range(8)]
     c0 = cirq.H(qubits[0])
     c7 = cirq.H(qubits[7])
@@ -4055,7 +4057,7 @@ def test_moment_groups(circuit_cls):
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_moments_property(circuit_cls):
+def test_moments_property(circuit_cls) -> None:
     q = cirq.NamedQubit('q')
     c = circuit_cls(cirq.X(q), cirq.Y(q))
     assert c.moments[0] == cirq.Moment([cirq.X(q)])
@@ -4063,16 +4065,17 @@ def test_moments_property(circuit_cls):
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_json_dict(circuit_cls):
+def test_json_dict(circuit_cls) -> None:
     q0, q1 = cirq.LineQubit.range(2)
     c = circuit_cls(cirq.CNOT(q0, q1))
+    moments: Sequence[cirq.Moment]
     moments = [cirq.Moment([cirq.CNOT(q0, q1)])]
     if circuit_cls == cirq.FrozenCircuit:
         moments = tuple(moments)
     assert c._json_dict_() == {'moments': moments}
 
 
-def test_with_noise():
+def test_with_noise() -> None:
     class Noise(cirq.NoiseModel):
         def noisy_operation(self, operation):
             yield operation
@@ -4107,7 +4110,7 @@ def noisy_operation(self, operation):
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_init_contents(circuit_cls):
+def test_init_contents(circuit_cls) -> None:
     a, b = cirq.LineQubit.range(2)
 
     # Moments are not subject to insertion rules.
@@ -4129,7 +4132,7 @@ def test_init_contents(circuit_cls):
     circuit_cls()
 
 
-def test_transform_qubits():
+def test_transform_qubits() -> None:
     a, b, c = cirq.LineQubit.range(3)
     original = cirq.Circuit(
         cirq.X(a), cirq.CNOT(a, b), cirq.Moment(), cirq.Moment([cirq.CNOT(b, c)])
@@ -4138,7 +4141,12 @@ def test_transform_qubits():
     desired = cirq.Circuit(
         cirq.X(x), cirq.CNOT(x, y), cirq.Moment(), cirq.Moment([cirq.CNOT(y, z)])
     )
-    assert original.transform_qubits(lambda q: cirq.GridQubit(10 + q.x, 20)) == desired
+    assert (
+        original.transform_qubits(
+            lambda q: cirq.GridQubit(10 + q.x, 20)  # type: ignore[attr-defined]
+        )
+        == desired
+    )
     assert (
         original.transform_qubits(
             {
@@ -4150,11 +4158,11 @@ def test_transform_qubits():
         == desired
     )
     with pytest.raises(TypeError, match='must be a function or dict'):
-        _ = original.transform_qubits('bad arg')
+        _ = original.transform_qubits('bad arg')  # type: ignore[arg-type]
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_indexing_by_pair(circuit_cls):
+def test_indexing_by_pair(circuit_cls) -> None:
     # 0: ───H───@───X───@───
     #           │       │
     # 1: ───────H───@───@───
@@ -4256,7 +4264,7 @@ def test_indexing_by_pair(circuit_cls):
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_indexing_by_numpy_integer(circuit_cls):
+def test_indexing_by_numpy_integer(circuit_cls) -> None:
     q = cirq.NamedQubit('q')
     c = circuit_cls(cirq.X(q), cirq.Y(q))
 
@@ -4265,7 +4273,7 @@ def test_indexing_by_numpy_integer(circuit_cls):
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_all_measurement_key_names(circuit_cls):
+def test_all_measurement_key_names(circuit_cls) -> None:
     class Unknown(cirq.testing.SingleQubitGate):
         def _measurement_key_name_(self):
             return 'test'
@@ -4298,7 +4306,7 @@ def _measurement_key_name_(self):
     ).all_measurement_key_names() == {'x', 'y'}
 
 
-def test_zip():
+def test_zip() -> None:
     a, b, c, d = cirq.LineQubit.range(4)
 
     circuit1 = cirq.Circuit(cirq.H(a), cirq.CNOT(a, b))
@@ -4340,7 +4348,7 @@ def test_zip():
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_zip_alignment(circuit_cls):
+def test_zip_alignment(circuit_cls) -> None:
     a, b, c = cirq.LineQubit.range(3)
 
     circuit1 = circuit_cls([cirq.H(a)] * 5)
@@ -4367,7 +4375,7 @@ def test_zip_alignment(circuit_cls):
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_repr_html_escaping(circuit_cls):
+def test_repr_html_escaping(circuit_cls) -> None:
     class TestGate(cirq.Gate):
         def num_qubits(self):
             return 2
@@ -4388,7 +4396,7 @@ def _circuit_diagram_info_(self, args):
     assert '|c&gt;' in circuit._repr_html_()
 
 
-def test_concat_ragged():
+def test_concat_ragged() -> None:
     a, b = cirq.LineQubit.range(2)
     empty = cirq.Circuit()
 
@@ -4535,6 +4543,7 @@ def test_concat_ragged():
         )
 
     # Types.
+    v: cirq.AbstractCircuit
     v = ha.freeze().concat_ragged(empty)
     assert type(v) is cirq.FrozenCircuit and v == ha.freeze()
     v = ha.concat_ragged(empty.freeze())
@@ -4547,7 +4556,7 @@ def test_concat_ragged():
     assert type(v) is cirq.FrozenCircuit and v == ha.freeze()
 
 
-def test_concat_ragged_alignment():
+def test_concat_ragged_alignment() -> None:
     a, b = cirq.LineQubit.range(2)
 
     assert cirq.Circuit.concat_ragged(
@@ -4579,14 +4588,14 @@ def test_concat_ragged_alignment():
     )
 
 
-def test_freeze_not_relocate_moments():
+def test_freeze_not_relocate_moments() -> None:
     q = cirq.q(0)
     c = cirq.Circuit(cirq.X(q), cirq.measure(q))
     f = c.freeze()
     assert [mc is fc for mc, fc in zip(c, f)] == [True, True]
 
 
-def test_freeze_is_cached():
+def test_freeze_is_cached() -> None:
     q = cirq.q(0)
     c = cirq.Circuit(cirq.X(q), cirq.measure(q))
     f0 = c.freeze()
@@ -4645,7 +4654,7 @@ def test_freeze_is_cached():
         ),
     ],
 )
-def test_mutation_clears_cached_attributes(circuit, mutate):
+def test_mutation_clears_cached_attributes(circuit, mutate) -> None:
     cached_attributes = [
         "_all_qubits",
         "_frozen",
@@ -4680,7 +4689,7 @@ def test_mutation_clears_cached_attributes(circuit, mutate):
         assert getattr(circuit, attr) is None, f"{attr=} is not None"
 
 
-def test_factorize_one_factor():
+def test_factorize_one_factor() -> None:
     circuit = cirq.Circuit()
     q0, q1, q2 = cirq.LineQubit.range(3)
     circuit.append(
@@ -4699,7 +4708,7 @@ def test_factorize_one_factor():
     cirq.testing.assert_has_diagram(factors[0], desired)
 
 
-def test_factorize_simple_circuit_two_factors():
+def test_factorize_simple_circuit_two_factors() -> None:
     circuit = cirq.Circuit()
     q0, q1, q2 = cirq.LineQubit.range(3)
     circuit.append([cirq.H(q1), cirq.CZ(q0, q1), cirq.H(q2), cirq.H(q0), cirq.H(q0)])
@@ -4719,7 +4728,7 @@ def test_factorize_simple_circuit_two_factors():
         cirq.testing.assert_has_diagram(f, d)
 
 
-def test_factorize_large_circuit():
+def test_factorize_large_circuit() -> None:
     circuit = cirq.Circuit()
     qubits = cirq.GridQubit.rect(3, 3)
     circuit.append(cirq.Moment(cirq.X(q) for q in qubits))
@@ -4759,7 +4768,7 @@ def test_factorize_large_circuit():
         cirq.testing.assert_has_diagram(f, d)
 
 
-def test_zero_target_operations_go_below_diagram():
+def test_zero_target_operations_go_below_diagram() -> None:
     class CustomOperationAnnotation(cirq.Operation):
         def __init__(self, text: str):
             self.text = text
@@ -4874,7 +4883,7 @@ def _circuit_diagram_info_(self, args) -> str:
     )
 
 
-def test_create_speed():
+def test_create_speed() -> None:
     # Added in https://github.com/quantumlib/Cirq/pull/5332
     # Previously this took ~30s to run. Now it should take ~150ms. However the coverage test can
     # run this slowly, so allowing 4 sec to account for things like that. Feel free to increase the
@@ -4890,7 +4899,7 @@ def test_create_speed():
     assert duration < 4
 
 
-def test_append_speed():
+def test_append_speed() -> None:
     # Previously this took ~17s to run. Now it should take ~150ms. However the coverage test can
     # run this slowly, so allowing 5 sec to account for things like that. Feel free to increase the
     # buffer time or delete the test entirely if it ends up causing flakes.
diff --git a/cirq-core/cirq/circuits/moment_test.py b/cirq-core/cirq/circuits/moment_test.py
index cd0eb856c88..6d57e497419 100644
--- a/cirq-core/cirq/circuits/moment_test.py
+++ b/cirq-core/cirq/circuits/moment_test.py
@@ -22,7 +22,7 @@
 import cirq.testing
 
 
-def test_validation():
+def test_validation() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
     c = cirq.NamedQubit('c')
@@ -44,7 +44,7 @@ def test_validation():
         _ = cirq.Moment([cirq.CZ(a, c), cirq.CZ(c, d)])
 
 
-def test_equality():
+def test_equality() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
     c = cirq.NamedQubit('c')
@@ -71,7 +71,7 @@ def test_equality():
     eq.make_equality_group(lambda: cirq.Moment([cirq.CZ(a, c), cirq.CZ(b, d)]))
 
 
-def test_approx_eq():
+def test_approx_eq() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
 
@@ -97,7 +97,7 @@ def test_approx_eq():
     )
 
 
-def test_operates_on_single_qubit():
+def test_operates_on_single_qubit() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
     c = cirq.NamedQubit('c')
@@ -121,7 +121,7 @@ def test_operates_on_single_qubit():
     assert not cirq.Moment([cirq.X(a), cirq.X(b)]).operates_on_single_qubit(c)
 
 
-def test_operates_on():
+def test_operates_on() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
     c = cirq.NamedQubit('c')
@@ -157,7 +157,7 @@ def test_operates_on():
     assert cirq.Moment([cirq.X(a), cirq.X(b)]).operates_on([a, b, c])
 
 
-def test_operation_at():
+def test_operation_at() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
     c = cirq.NamedQubit('c')
@@ -172,14 +172,14 @@ def test_operation_at():
     assert cirq.Moment([cirq.CZ(a, b), cirq.X(c)]).operation_at(a) == cirq.CZ(a, b)
 
 
-def test_from_ops():
+def test_from_ops() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
 
     assert cirq.Moment.from_ops(cirq.X(a), cirq.Y(b)) == cirq.Moment(cirq.X(a), cirq.Y(b))
 
 
-def test_with_operation():
+def test_with_operation() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
 
@@ -204,7 +204,7 @@ def test_with_operation():
         _ = cirq.Moment([cirq.X(a), cirq.X(b)]).with_operation(cirq.X(b))
 
 
-def test_with_operations():
+def test_with_operations() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
     c = cirq.NamedQubit('c')
@@ -238,7 +238,7 @@ def test_with_operations():
         _ = cirq.Moment([cirq.X(a), cirq.X(b)]).with_operations(cirq.X(b))
 
 
-def test_without_operations_touching():
+def test_without_operations_touching() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
     c = cirq.NamedQubit('c')
@@ -284,14 +284,14 @@ def test_without_operations_touching():
     )
 
 
-def test_is_parameterized():
+def test_is_parameterized() -> None:
     a, b = cirq.LineQubit.range(2)
     moment = cirq.Moment(cirq.X(a) ** sympy.Symbol('v'), cirq.Y(b) ** sympy.Symbol('w'))
     assert cirq.is_parameterized(moment)
     assert not cirq.is_parameterized(cirq.Moment(cirq.X(a), cirq.Y(b)))
 
 
-def test_resolve_parameters():
+def test_resolve_parameters() -> None:
     a, b = cirq.LineQubit.range(2)
     moment = cirq.Moment(cirq.X(a) ** sympy.Symbol('v'), cirq.Y(b) ** sympy.Symbol('w'))
     resolved_moment = cirq.resolve_parameters(moment, cirq.ParamResolver({'v': 0.1, 'w': 0.2}))
@@ -301,12 +301,13 @@ def test_resolve_parameters():
     resolved_moment = cirq.resolve_parameters(moment, {'pi': np.pi})
     assert resolved_moment == cirq.Moment(cirq.Rz(rads=np.pi).on(a))
     resolved_gate = resolved_moment.operations[0].gate
+    assert isinstance(resolved_gate, cirq.Rz)
     assert not isinstance(resolved_gate.exponent, sympy.Basic)
     assert isinstance(resolved_gate.exponent, float)
     assert not cirq.is_parameterized(resolved_moment)
 
 
-def test_resolve_parameters_no_change():
+def test_resolve_parameters_no_change() -> None:
     a, b = cirq.LineQubit.range(2)
     moment = cirq.Moment(cirq.X(a), cirq.Y(b))
     resolved_moment = cirq.resolve_parameters(moment, cirq.ParamResolver({'v': 0.1, 'w': 0.2}))
@@ -317,14 +318,14 @@ def test_resolve_parameters_no_change():
     assert resolved_moment is moment
 
 
-def test_parameter_names():
+def test_parameter_names() -> None:
     a, b = cirq.LineQubit.range(2)
     moment = cirq.Moment(cirq.X(a) ** sympy.Symbol('v'), cirq.Y(b) ** sympy.Symbol('w'))
     assert cirq.parameter_names(moment) == {'v', 'w'}
     assert cirq.parameter_names(cirq.Moment(cirq.X(a), cirq.Y(b))) == set()
 
 
-def test_with_measurement_keys():
+def test_with_measurement_keys() -> None:
     a, b = cirq.LineQubit.range(2)
     m = cirq.Moment(cirq.measure(a, key='m1'), cirq.measure(b, key='m2'))
 
@@ -334,7 +335,7 @@ def test_with_measurement_keys():
     assert new_moment.operations[1] == cirq.measure(b, key='p2')
 
 
-def test_with_key_path():
+def test_with_key_path() -> None:
     a, b = cirq.LineQubit.range(2)
     m = cirq.Moment(cirq.measure(a, key='m1'), cirq.measure(b, key='m2'))
 
@@ -348,7 +349,7 @@ def test_with_key_path():
     )
 
 
-def test_with_key_path_prefix():
+def test_with_key_path_prefix() -> None:
     a, b, c = cirq.LineQubit.range(3)
     m = cirq.Moment(cirq.measure(a, key='m1'), cirq.measure(b, key='m2'), cirq.X(c))
     mb = cirq.with_key_path_prefix(m, ('b',))
@@ -358,7 +359,7 @@ def test_with_key_path_prefix():
     assert mab.operations[2] is m.operations[2]
 
 
-def test_copy():
+def test_copy() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
     original = cirq.Moment([cirq.CZ(a, b)])
@@ -367,7 +368,7 @@ def test_copy():
     assert id(original) != id(copy)
 
 
-def test_qubits():
+def test_qubits() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
 
@@ -376,7 +377,7 @@ def test_qubits():
     assert cirq.Moment([cirq.CZ(a, b)]).qubits == {a, b}
 
 
-def test_container_methods():
+def test_container_methods() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
     m = cirq.Moment([cirq.H(a), cirq.H(b)])
@@ -389,14 +390,14 @@ def test_container_methods():
     assert len(m) == 2
 
 
-def test_decompose():
+def test_decompose() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
     m = cirq.Moment(cirq.X(a), cirq.X(b))
     assert list(cirq.decompose(m)) == list(m.operations)
 
 
-def test_measurement_keys():
+def test_measurement_keys() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
     m = cirq.Moment(cirq.X(a), cirq.X(b))
@@ -409,7 +410,7 @@ def test_measurement_keys():
     assert cirq.is_measurement(m2)
 
 
-def test_measurement_key_objs_caching():
+def test_measurement_key_objs_caching() -> None:
     q0, q1, q2, q3 = cirq.LineQubit.range(4)
     m = cirq.Moment(cirq.measure(q0, key='foo'))
     assert m._measurement_key_objs is None
@@ -432,7 +433,7 @@ def test_measurement_key_objs_caching():
     }
 
 
-def test_control_keys_caching():
+def test_control_keys_caching() -> None:
     q0, q1, q2, q3 = cirq.LineQubit.range(4)
     m = cirq.Moment(cirq.X(q0).with_classical_controls('foo'))
     assert m._control_keys is None
@@ -454,13 +455,13 @@ def test_control_keys_caching():
     }
 
 
-def test_bool():
+def test_bool() -> None:
     assert not cirq.Moment()
     a = cirq.NamedQubit('a')
     assert cirq.Moment([cirq.X(a)])
 
 
-def test_repr():
+def test_repr() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
 
@@ -469,14 +470,14 @@ def test_repr():
     cirq.testing.assert_equivalent_repr(cirq.Moment(cirq.X(a), cirq.Y(b)))
 
 
-def test_json_dict():
+def test_json_dict() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
     mom = cirq.Moment([cirq.CZ(a, b)])
     assert mom._json_dict_() == {'operations': (cirq.CZ(a, b),)}
 
 
-def test_inverse():
+def test_inverse() -> None:
     a, b, c = cirq.LineQubit.range(3)
     m = cirq.Moment([cirq.S(a), cirq.CNOT(b, c)])
     assert m**1 is m
@@ -487,15 +488,15 @@ def test_inverse():
     assert cirq.inverse(cirq.Moment([cirq.measure(a)]), default=None) is None
 
 
-def test_immutable_moment():
+def test_immutable_moment() -> None:
     with pytest.raises(AttributeError):
         q1, q2 = cirq.LineQubit.range(2)
         circuit = cirq.Circuit(cirq.X(q1))
         moment = circuit.moments[0]
-        moment.operations += (cirq.Y(q2),)
+        moment.operations += (cirq.Y(q2),)  # type: ignore[misc]
 
 
-def test_add():
+def test_add() -> None:
     a, b, c = cirq.LineQubit.range(3)
     expected_circuit = cirq.Circuit([cirq.CNOT(a, b), cirq.X(a), cirq.Y(b)])
 
@@ -520,7 +521,7 @@ def test_add():
     assert m1 + [] is m1
 
 
-def test_sub():
+def test_sub() -> None:
     a, b, c = cirq.LineQubit.range(3)
     m = cirq.Moment(cirq.X(a), cirq.Y(b))
     assert m - [] == m
@@ -539,7 +540,7 @@ def test_sub():
     assert m2 - cirq.Y(b) == cirq.Moment(cirq.X(a), cirq.Z(c))
 
 
-def test_op_tree():
+def test_op_tree() -> None:
     eq = cirq.testing.EqualsTester()
     a, b = cirq.LineQubit.range(2)
 
@@ -552,7 +553,7 @@ def test_op_tree():
     eq.add_equality_group(cirq.Moment(cirq.X(a), cirq.Y(b)), cirq.Moment([cirq.X(a), cirq.Y(b)]))
 
 
-def test_indexes_by_qubit():
+def test_indexes_by_qubit() -> None:
     a, b, c = cirq.LineQubit.range(3)
     moment = cirq.Moment([cirq.H(a), cirq.CNOT(b, c)])
 
@@ -561,7 +562,7 @@ def test_indexes_by_qubit():
     assert moment[c] == cirq.CNOT(b, c)
 
 
-def test_throws_when_indexed_by_unused_qubit():
+def test_throws_when_indexed_by_unused_qubit() -> None:
     a, b = cirq.LineQubit.range(2)
     moment = cirq.Moment([cirq.H(a)])
 
@@ -569,7 +570,7 @@ def test_throws_when_indexed_by_unused_qubit():
         _ = moment[b]
 
 
-def test_indexes_by_list_of_qubits():
+def test_indexes_by_list_of_qubits() -> None:
     q = cirq.LineQubit.range(4)
     moment = cirq.Moment([cirq.Z(q[0]), cirq.CNOT(q[1], q[2])])
 
@@ -584,7 +585,11 @@ def test_indexes_by_list_of_qubits():
     assert moment[q] == moment
 
 
-def test_moment_text_diagram():
+def test_moment_text_diagram() -> None:
+    a: cirq.Qid
+    b: cirq.Qid
+    c: cirq.Qid
+    d: cirq.Qid
     a, b, c, d = cirq.GridQubit.rect(2, 2)
     m = cirq.Moment(cirq.CZ(a, b), cirq.CNOT(c, d))
     assert (
@@ -674,7 +679,7 @@ def __str__(self):
     )
 
 
-def test_text_diagram_does_not_depend_on_insertion_order():
+def test_text_diagram_does_not_depend_on_insertion_order() -> None:
     q = cirq.LineQubit.range(4)
     ops = [cirq.CNOT(q[0], q[3]), cirq.CNOT(q[1], q[2])]
     m1, m2 = cirq.Moment(ops), cirq.Moment(ops[::-1])
@@ -682,7 +687,7 @@ def test_text_diagram_does_not_depend_on_insertion_order():
     assert str(m1) == str(m2)
 
 
-def test_commutes_moment_and_operation():
+def test_commutes_moment_and_operation() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
     c = cirq.NamedQubit('c')
@@ -712,7 +717,7 @@ def test_commutes_moment_and_operation():
     assert cirq.commutes(moment, cirq.XX(a, b))
 
 
-def test_commutes_moment_and_moment():
+def test_commutes_moment_and_moment() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
     c = cirq.NamedQubit('c')
@@ -733,7 +738,7 @@ def test_commutes_moment_and_moment():
     )
 
 
-def test_commutes_moment_with_controls():
+def test_commutes_moment_with_controls() -> None:
     a, b = cirq.LineQubit.range(2)
     assert cirq.commutes(
         cirq.Moment(cirq.measure(a, key='k0')), cirq.Moment(cirq.X(b).with_classical_controls('k1'))
@@ -761,7 +766,7 @@ def test_commutes_moment_with_controls():
     )
 
 
-def test_commutes_moment_and_moment_comprehensive():
+def test_commutes_moment_and_moment_comprehensive() -> None:
     a, b, c, d = cirq.LineQubit.range(4)
 
     # Basic Z⊗Z commuting with XX at different angles
@@ -790,7 +795,7 @@ def test_commutes_moment_and_moment_comprehensive():
     assert not cirq.commutes(m1, m2)  # Z⊗Z⊗Z doesn't commute with XX⊗X
 
 
-def test_commutes_handles_non_unitary_operation():
+def test_commutes_handles_non_unitary_operation() -> None:
     a = cirq.NamedQubit('a')
     op_damp_a = cirq.AmplitudeDampingChannel(gamma=0.1).on(a)
     assert cirq.commutes(cirq.Moment(cirq.X(a)), op_damp_a, default=None) is None
@@ -798,7 +803,7 @@ def test_commutes_handles_non_unitary_operation():
     assert cirq.commutes(cirq.Moment(op_damp_a), cirq.Moment(op_damp_a))
 
 
-def test_transform_qubits():
+def test_transform_qubits() -> None:
     a, b = cirq.LineQubit.range(2)
     x, y = cirq.GridQubit.rect(2, 1, 10, 20)
 
@@ -806,12 +811,17 @@ def test_transform_qubits():
     modified = cirq.Moment([cirq.X(x), cirq.Y(y)])
 
     assert original.transform_qubits({a: x, b: y}) == modified
-    assert original.transform_qubits(lambda q: cirq.GridQubit(10 + q.x, 20)) == modified
+    assert (
+        original.transform_qubits(
+            lambda q: cirq.GridQubit(10 + q.x, 20)  # type: ignore[attr-defined]
+        )
+        == modified
+    )
     with pytest.raises(TypeError, match='must be a function or dict'):
-        _ = original.transform_qubits('bad arg')
+        _ = original.transform_qubits('bad arg')  # type: ignore[arg-type]
 
 
-def test_expand_to():
+def test_expand_to() -> None:
     a, b = cirq.LineQubit.range(2)
     m1 = cirq.Moment(cirq.H(a))
     m2 = m1.expand_to({a})
@@ -826,7 +836,7 @@ def test_expand_to():
         _ = m1.expand_to({b})
 
 
-def test_kraus():
+def test_kraus() -> None:
     I = np.eye(2)
     X = np.array([[0, 1], [1, 0]])
     Y = np.array([[0, -1j], [1j, 0]])
@@ -874,7 +884,7 @@ def test_kraus():
     assert np.allclose(k[3], np.sqrt(p * q) * np.kron(X, Z))
 
 
-def test_kraus_too_big():
+def test_kraus_too_big() -> None:
     m = cirq.Moment(cirq.IdentityGate(11).on(*cirq.LineQubit.range(11)))
     assert not cirq.has_kraus(m)
     assert not m._has_superoperator_()
@@ -883,7 +893,7 @@ def test_kraus_too_big():
     assert cirq.kraus(m, default=None) is None
 
 
-def test_op_has_no_kraus():
+def test_op_has_no_kraus() -> None:
     class EmptyGate(cirq.testing.SingleQubitGate):
         pass
 
@@ -895,7 +905,7 @@ class EmptyGate(cirq.testing.SingleQubitGate):
     assert cirq.kraus(m, default=None) is None
 
 
-def test_superoperator():
+def test_superoperator() -> None:
     cnot = cirq.unitary(cirq.CNOT)
 
     a, b = cirq.LineQubit.range(2)
diff --git a/cirq-core/cirq/circuits/optimization_pass.py b/cirq-core/cirq/circuits/optimization_pass.py
index 98a4ba376e9..e160151cb6f 100644
--- a/cirq-core/cirq/circuits/optimization_pass.py
+++ b/cirq-core/cirq/circuits/optimization_pass.py
@@ -126,7 +126,7 @@ def optimization_at(
             change should be made.
         """
 
-    def optimize_circuit(self, circuit: cirq.Circuit):
+    def optimize_circuit(self, circuit: cirq.Circuit) -> None:
         frontier: dict[cirq.Qid, int] = defaultdict(lambda: 0)
         i = 0
         while i < len(circuit):  # Note: circuit may mutate as we go.
diff --git a/cirq-core/cirq/circuits/text_diagram_drawer.py b/cirq-core/cirq/circuits/text_diagram_drawer.py
index baf0fc7d7a9..80c078f3e02 100644
--- a/cirq-core/cirq/circuits/text_diagram_drawer.py
+++ b/cirq-core/cirq/circuits/text_diagram_drawer.py
@@ -14,7 +14,7 @@
 
 from __future__ import annotations
 
-from typing import Any, Callable, cast, Iterable, Mapping, NamedTuple, Sequence, TYPE_CHECKING
+from typing import Any, Callable, cast, Iterable, Mapping, NamedTuple, Self, Sequence, TYPE_CHECKING
 
 import numpy as np
 
@@ -63,8 +63,8 @@ def __init__(
         entries: Mapping[tuple[int, int], _DiagramText] | None = None,
         horizontal_lines: Iterable[_HorizontalLine] | None = None,
         vertical_lines: Iterable[_VerticalLine] | None = None,
-        horizontal_padding: Mapping[int, int] | None = None,
-        vertical_padding: Mapping[int, int] | None = None,
+        horizontal_padding: Mapping[int, float] | None = None,
+        vertical_padding: Mapping[int, float] | None = None,
     ) -> None:
         self.entries: dict[tuple[int, int], _DiagramText] = (
             dict() if entries is None else dict(entries)
@@ -95,7 +95,7 @@ def _value_equality_values_(self):
     def __bool__(self):
         return any(self._value_equality_values_())
 
-    def write(self, x: int, y: int, text: str, transposed_text: str | None = None):
+    def write(self, x: int, y: int, text: str, transposed_text: str | None = None) -> None:
         """Adds text to the given location.
 
         Args:
@@ -130,7 +130,7 @@ def content_present(self, x: int, y: int) -> bool:
 
     def grid_line(
         self, x1: int, y1: int, x2: int, y2: int, emphasize: bool = False, doubled: bool = False
-    ):
+    ) -> None:
         """Adds a vertical or horizontal line from (x1, y1) to (x2, y2).
 
         Horizontal line is selected on equality in the second coordinate and
@@ -313,7 +313,7 @@ def render(
 
         return block_diagram.render()
 
-    def copy(self):
+    def copy(self) -> Self:
         return self.__class__(
             entries=self.entries,
             vertical_lines=self.vertical_lines,
diff --git a/cirq-core/cirq/conftest.py b/cirq-core/cirq/conftest.py
index 7991723c145..0a36c8e4bdb 100644
--- a/cirq-core/cirq/conftest.py
+++ b/cirq-core/cirq/conftest.py
@@ -14,18 +14,19 @@
 
 import inspect
 import os
+from collections.abc import Iterator
 
 import matplotlib.pyplot as plt
 import pytest
 
 
-def pytest_configure(config):
+def pytest_configure(config) -> None:
     # Use matplotlib agg backend which does not require a display.
     plt.switch_backend('agg')
     os.environ['CIRQ_TESTING'] = "true"
 
 
-def pytest_pyfunc_call(pyfuncitem):
+def pytest_pyfunc_call(pyfuncitem) -> None:
     if inspect.iscoroutinefunction(pyfuncitem._obj):
         raise ValueError(  # pragma: no cover
             f'{pyfuncitem._obj.__name__} is a bare async function. '
@@ -34,6 +35,6 @@ def pytest_pyfunc_call(pyfuncitem):
 
 
 @pytest.fixture
-def closefigures():
+def closefigures() -> Iterator[None]:
     yield
     plt.close('all')
diff --git a/cirq-core/cirq/contrib/acquaintance/bipartite_test.py b/cirq-core/cirq/contrib/acquaintance/bipartite_test.py
index c6fc8e2fbcc..ca908707430 100644
--- a/cirq-core/cirq/contrib/acquaintance/bipartite_test.py
+++ b/cirq-core/cirq/contrib/acquaintance/bipartite_test.py
@@ -270,7 +270,7 @@
 @pytest.mark.parametrize(
     'subgraph,part_size', itertools.product(cca.BipartiteGraphType, range(1, 5))
 )
-def test_circuit_diagrams(part_size, subgraph):
+def test_circuit_diagrams(part_size, subgraph) -> None:
     qubits = cirq.LineQubit.range(2 * part_size)
     gate = cca.BipartiteSwapNetworkGate(subgraph, part_size)
     circuit = cirq.Circuit(gate(*qubits))
@@ -285,10 +285,10 @@ def test_circuit_diagrams(part_size, subgraph):
     cirq.testing.assert_has_diagram(circuit, diagram)
 
 
-def test_bad_args():
+def test_bad_args() -> None:
     gate = cca.BipartiteSwapNetworkGate(cca.BipartiteGraphType.COMPLETE, 2)
     qubits = cirq.LineQubit.range(4)
-    gate.subgraph = 'not a subgraph'
+    gate.subgraph = 'not a subgraph'  # type: ignore[assignment]
     args = cirq.CircuitDiagramInfoArgs(
         known_qubits=None,
         known_qubit_count=None,
@@ -306,7 +306,7 @@ def test_bad_args():
     with pytest.raises(ValueError):
         gate._decompose_(qubits[:3])
 
-    gate.subgraph = 'unimplemented subgraph'
+    gate.subgraph = 'unimplemented subgraph'  # type: ignore[assignment]
     with pytest.raises(NotImplementedError):
         gate._decompose_(qubits)
 
@@ -315,7 +315,7 @@ def test_bad_args():
         gate._circuit_diagram_info_(args)
 
 
-def test_bipartite_swap_network_acquaintance_size():
+def test_bipartite_swap_network_acquaintance_size() -> None:
     qubits = cirq.LineQubit.range(4)
     gate = cca.BipartiteSwapNetworkGate(cca.BipartiteGraphType.COMPLETE, 2)
     assert cca.get_acquaintance_size(gate(*qubits)) == 2
@@ -324,7 +324,7 @@ def test_bipartite_swap_network_acquaintance_size():
 @pytest.mark.parametrize(
     'subgraph,part_size', itertools.product(cca.BipartiteGraphType, range(1, 3))
 )
-def test_repr(subgraph, part_size):
+def test_repr(subgraph, part_size) -> None:
     gate = cca.BipartiteSwapNetworkGate(subgraph, part_size)
     cirq.testing.assert_equivalent_repr(gate)
 
@@ -335,18 +335,20 @@ def test_repr(subgraph, part_size):
 @pytest.mark.parametrize(
     'subgraph,part_size', itertools.product(cca.BipartiteGraphType, range(1, 6))
 )
-def test_decomposition_permutation_consistency(part_size, subgraph):
+def test_decomposition_permutation_consistency(part_size, subgraph) -> None:
     gate = cca.BipartiteSwapNetworkGate(subgraph, part_size)
     qubits = cirq.LineQubit.range(2 * part_size)
+    mapping: dict[cirq.Qid, int]
     mapping = {q: i for i, q in enumerate(qubits)}
     cca.update_mapping(mapping, gate._decompose_(qubits))
     permutation = gate.permutation()
     assert {qubits[i]: j for i, j in permutation.items()} == mapping
 
 
-def test_bad_number_of_qubits():
+def test_bad_number_of_qubits() -> None:
     gate = cca.BipartiteSwapNetworkGate(cca.BipartiteGraphType.COMPLETE, 6)
     qubits = cirq.LineQubit.range(6)
+    mapping: dict[cirq.Qid, int]
     mapping = {q: i for i, q in enumerate(qubits)}
     with pytest.raises(ValueError, match='len'):
         cca.update_mapping(mapping, gate._decompose_(qubits))
diff --git a/cirq-core/cirq/contrib/acquaintance/devices_test.py b/cirq-core/cirq/contrib/acquaintance/devices_test.py
index aa1a318e4c5..22f43d2ec02 100644
--- a/cirq-core/cirq/contrib/acquaintance/devices_test.py
+++ b/cirq-core/cirq/contrib/acquaintance/devices_test.py
@@ -20,7 +20,7 @@
 import cirq.contrib.acquaintance as cca
 
 
-def test_acquaintance_device():
+def test_acquaintance_device() -> None:
     with pytest.raises(ValueError):
         op = cirq.X(cirq.NamedQubit('q'))
         cca.UnconstrainedAcquaintanceDevice.validate_operation(op)
@@ -31,6 +31,6 @@ def test_acquaintance_device():
     cca.UnconstrainedAcquaintanceDevice.validate_operation(swap_network(*qubits))
 
 
-def test_not_operation():
+def test_not_operation() -> None:
     with pytest.raises(TypeError):
-        _ = cca.get_acquaintance_size(cirq.LineQubit(1))
+        _ = cca.get_acquaintance_size(cirq.LineQubit(1))  # type: ignore[arg-type]
diff --git a/cirq-core/cirq/contrib/acquaintance/executor_test.py b/cirq-core/cirq/contrib/acquaintance/executor_test.py
index 2af8f050460..83f29b7cda8 100644
--- a/cirq-core/cirq/contrib/acquaintance/executor_test.py
+++ b/cirq-core/cirq/contrib/acquaintance/executor_test.py
@@ -16,7 +16,7 @@
 
 from itertools import combinations
 from string import ascii_lowercase
-from typing import Sequence
+from typing import Any, Sequence
 
 import numpy as np
 import pytest
@@ -38,11 +38,12 @@ def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs):
         return self._wire_symbols
 
 
-def test_executor_explicit():
+def test_executor_explicit() -> None:
     num_qubits = 8
     qubits = cirq.LineQubit.range(num_qubits)
     circuit = cca.complete_acquaintance_strategy(qubits, 2)
 
+    gates: dict[tuple[Any, ...], cirq.Gate]
     gates = {
         (i, j): ExampleGate([str(k) for k in ij])
         for ij in combinations(range(num_qubits), 2)
@@ -53,10 +54,11 @@ def test_executor_explicit():
     assert execution_strategy.device == cirq.UNCONSTRAINED_DEVICE
 
     with pytest.raises(ValueError):
-        executor = cca.StrategyExecutorTransformer(None)
+        executor = cca.StrategyExecutorTransformer(None)  # type: ignore[arg-type]
     executor = cca.StrategyExecutorTransformer(execution_strategy)
 
     with pytest.raises(NotImplementedError):
+        bad_gates: dict[tuple[Any, ...], cirq.Gate]
         bad_gates = {(0,): ExampleGate(['0']), (0, 1): ExampleGate(['0', '1'])}
         cca.GreedyExecutionStrategy(bad_gates, initial_mapping)
 
@@ -107,7 +109,7 @@ def random_diagonal_gates(
 )
 def test_executor_random(
     num_qubits: int, acquaintance_size: int, gates: dict[tuple[cirq.Qid, ...], cirq.Gate]
-):
+) -> None:
     qubits = cirq.LineQubit.range(num_qubits)
     circuit = cca.complete_acquaintance_strategy(qubits, acquaintance_size)
 
@@ -126,7 +128,7 @@ def test_executor_random(
     np.testing.assert_allclose(actual=actual_unitary, desired=expected_unitary, verbose=True)
 
 
-def test_acquaintance_operation():
+def test_acquaintance_operation() -> None:
     n = 5
     physical_qubits = tuple(cirq.LineQubit.range(n))
     logical_qubits = tuple(cirq.NamedQubit(s) for s in ascii_lowercase[:n])
@@ -134,7 +136,7 @@ def test_acquaintance_operation():
     with pytest.raises(ValueError):
         cca.AcquaintanceOperation(physical_qubits[:3], int_indices[:4])
     for logical_indices in (logical_qubits, int_indices):
-        op = cca.AcquaintanceOperation(physical_qubits, logical_indices)
+        op = cca.AcquaintanceOperation(physical_qubits, logical_indices)  # type: ignore[type-var]
         assert op.logical_indices == logical_indices
         assert op.qubits == physical_qubits
         wire_symbols = tuple(f'({i})' for i in logical_indices)
diff --git a/cirq-core/cirq/contrib/acquaintance/gates.py b/cirq-core/cirq/contrib/acquaintance/gates.py
index 9dddf294e1b..cf9db5c289f 100644
--- a/cirq-core/cirq/contrib/acquaintance/gates.py
+++ b/cirq-core/cirq/contrib/acquaintance/gates.py
@@ -148,7 +148,7 @@ def acquaint_and_shift(
     acquaintance_size: int | None,
     swap_gate: cirq.Gate,
     mapping: dict[ops.Qid, int],
-):
+) -> None:
     """Acquaints and shifts a pair of lists of qubits. The first part is
     acquainted with every qubit individually in the second part, and vice
     versa. Operations are grouped into several layers:
diff --git a/cirq-core/cirq/contrib/acquaintance/gates_test.py b/cirq-core/cirq/contrib/acquaintance/gates_test.py
index 52f05a3f38f..21546dac50c 100644
--- a/cirq-core/cirq/contrib/acquaintance/gates_test.py
+++ b/cirq-core/cirq/contrib/acquaintance/gates_test.py
@@ -27,7 +27,7 @@
 import cirq.testing as ct
 
 
-def test_acquaintance_gate_repr():
+def test_acquaintance_gate_repr() -> None:
     assert (
         repr(cca.AcquaintanceOpportunityGate(2))
         == 'cirq.contrib.acquaintance.AcquaintanceOpportunityGate'
@@ -35,7 +35,7 @@ def test_acquaintance_gate_repr():
     )
 
 
-def test_acquaintance_gate_text_diagram_info():
+def test_acquaintance_gate_text_diagram_info() -> None:
     qubits = [cirq.NamedQubit(s) for s in 'xyz']
     circuit = cirq.Circuit([cirq.Moment([cca.acquaint(*qubits)])])
     actual_text_diagram = circuit.to_text_diagram().strip()
@@ -49,11 +49,11 @@ def test_acquaintance_gate_text_diagram_info():
     assert actual_text_diagram == expected_text_diagram
 
 
-def test_acquaintance_gate_unknown_qubit_count():
+def test_acquaintance_gate_unknown_qubit_count() -> None:
     assert cirq.circuit_diagram_info(cca.acquaint, default=None) is None
 
 
-def test_swap_network_gate():
+def test_swap_network_gate() -> None:
     qubits = tuple(cirq.NamedQubit(s) for s in alphabet)
 
     acquaintance_size = 3
@@ -125,7 +125,7 @@ def test_swap_network_gate():
 @pytest.mark.parametrize(
     'part_lens', [tuple(randint(1, 3) for _ in range(randint(2, 10))) for _ in range(3)]
 )
-def test_acquaint_part_pairs(part_lens):
+def test_acquaint_part_pairs(part_lens) -> None:
     parts = []
     n_qubits = 0
     for part_len in part_lens:
@@ -154,13 +154,13 @@ def test_acquaint_part_pairs(part_lens):
         )
     ),
 )
-def test_swap_network_gate_permutation(part_lens, acquaintance_size):
+def test_swap_network_gate_permutation(part_lens, acquaintance_size) -> None:
     n_qubits = sum(part_lens)
     swap_network_gate = cca.SwapNetworkGate(part_lens, acquaintance_size)
     cca.testing.assert_permutation_decomposition_equivalence(swap_network_gate, n_qubits)
 
 
-def test_swap_network_gate_from_ops():
+def test_swap_network_gate_from_ops() -> None:
     n_qubits = 10
     qubits = cirq.LineQubit.range(n_qubits)
     part_lens = (1, 2, 1, 3, 3)
@@ -198,7 +198,7 @@ def test_swap_network_gate_from_ops():
     cirq.testing.assert_has_diagram(circuit, expected_diagram)
 
 
-def test_swap_network_decomposition():
+def test_swap_network_decomposition() -> None:
     qubits = cirq.LineQubit.range(8)
     swap_network_gate = cca.SwapNetworkGate((4, 4), 5)
     operations = cirq.decompose_once_with_qubits(swap_network_gate, qubits)
@@ -223,7 +223,7 @@ def test_swap_network_decomposition():
     ct.assert_has_diagram(circuit, expected_text_diagram)
 
 
-def test_swap_network_init_error():
+def test_swap_network_init_error() -> None:
     with pytest.raises(ValueError):
         cca.SwapNetworkGate(())
     with pytest.raises(ValueError):
@@ -237,7 +237,7 @@ def test_swap_network_init_error():
 
 
 @pytest.mark.parametrize('part_lens, acquaintance_size', part_lens_and_acquaintance_sizes)
-def test_swap_network_permutation(part_lens, acquaintance_size):
+def test_swap_network_permutation(part_lens, acquaintance_size) -> None:
     n_qubits = sum(part_lens)
     gate = cca.SwapNetworkGate(part_lens, acquaintance_size)
 
@@ -246,7 +246,7 @@ def test_swap_network_permutation(part_lens, acquaintance_size):
 
 
 @pytest.mark.parametrize('part_lens, acquaintance_size', part_lens_and_acquaintance_sizes)
-def test_swap_network_repr(part_lens, acquaintance_size):
+def test_swap_network_repr(part_lens, acquaintance_size) -> None:
     gate = cca.SwapNetworkGate(part_lens, acquaintance_size)
     ct.assert_equivalent_repr(gate)
 
@@ -260,16 +260,18 @@ def qubits(self) -> tuple[cirq.Qid, ...]:
         return self._qubits
 
     def with_qubits(self, *new_qubits: cirq.Qid) -> OtherOperation:
-        return type(self)(self._qubits)
+        return type(self)(new_qubits)
 
     def __eq__(self, other):
         return isinstance(other, type(self)) and self.qubits == other.qubits
 
 
-def test_get_acquaintance_size():
+def test_get_acquaintance_size() -> None:
+    qubits: Sequence[cirq.Qid]
     qubits = cirq.LineQubit.range(8)
+    op: cirq.Operation
     op = OtherOperation(qubits)
-    assert op.with_qubits(qubits) == op
+    assert op.with_qubits(*qubits) == op
     assert cca.get_acquaintance_size(op) == 0
 
     for s, _ in enumerate(qubits):
@@ -301,7 +303,7 @@ def test_get_acquaintance_size():
     assert cca.get_acquaintance_size(op) == 0
 
 
-def test_operations_to_part_lens():
+def test_operations_to_part_lens() -> None:
     qubits = cirq.LineQubit.range(6)
     ops = [cirq.CZ(*qubits[1:3]), cirq.XX(*qubits[3:5])]
     part_lens = cca.gates.operations_to_part_lens(qubits, ops)
@@ -319,7 +321,7 @@ def test_operations_to_part_lens():
 @pytest.mark.parametrize(
     'part_len_sets', [set(tuple(randint(1, 5) for _ in range(randint(2, 7))) for _ in range(5))]
 )
-def test_swap_network_gate_equality(part_len_sets):
+def test_swap_network_gate_equality(part_len_sets) -> None:
     acquaintance_sizes = [None, 0, 1, 2, 3]
     swap_gates = [cirq.SWAP, cirq.CNOT]
     equals_tester = ct.EqualsTester()
diff --git a/cirq-core/cirq/contrib/acquaintance/inspection_utils.py b/cirq-core/cirq/contrib/acquaintance/inspection_utils.py
index 42f4bb775c3..bd7f2714005 100644
--- a/cirq-core/cirq/contrib/acquaintance/inspection_utils.py
+++ b/cirq-core/cirq/contrib/acquaintance/inspection_utils.py
@@ -51,7 +51,9 @@ def get_operations(
         yield AcquaintanceOperation(qubits, indices)
 
 
-def get_acquaintance_dag(strategy: cirq.Circuit, initial_mapping: LogicalMapping):
+def get_acquaintance_dag(
+    strategy: cirq.Circuit, initial_mapping: LogicalMapping
+) -> circuitdag.CircuitDag:
     strategy = strategy.copy()
     expose_acquaintance_gates(strategy)
     LogicalAnnotator(initial_mapping)(strategy)
@@ -66,9 +68,11 @@ def get_acquaintance_dag(strategy: cirq.Circuit, initial_mapping: LogicalMapping
 
 def get_logical_acquaintance_opportunities(
     strategy: cirq.Circuit, initial_mapping: LogicalMapping
-) -> set[frozenset[LogicalIndex]]:
+) -> set[frozenset[int]] | set[frozenset[cirq.Qid]]:
     acquaintance_dag = get_acquaintance_dag(strategy, initial_mapping)
     logical_acquaintance_opportunities = set()
     for op in acquaintance_dag.all_operations():
-        logical_acquaintance_opportunities.add(frozenset(op.logical_indices))
+        logical_acquaintance_opportunities.add(
+            frozenset(op.logical_indices)  # type: ignore[attr-defined]
+        )
     return logical_acquaintance_opportunities
diff --git a/cirq-core/cirq/contrib/acquaintance/permutation_test.py b/cirq-core/cirq/contrib/acquaintance/permutation_test.py
index 28462dfeb1c..5d06bc8d5b3 100644
--- a/cirq-core/cirq/contrib/acquaintance/permutation_test.py
+++ b/cirq-core/cirq/contrib/acquaintance/permutation_test.py
@@ -15,6 +15,7 @@
 from __future__ import annotations
 
 import random
+from typing import Iterator
 
 import pytest
 
@@ -23,7 +24,7 @@
 import cirq.testing as ct
 
 
-def test_swap_permutation_gate():
+def test_swap_permutation_gate() -> None:
     no_decomp = lambda op: (isinstance(op, cirq.GateOperation) and op.gate == cirq.SWAP)
     a, b = cirq.NamedQubit('a'), cirq.NamedQubit('b')
     gate = cca.SwapPermutationGate()
@@ -42,7 +43,7 @@ def test_swap_permutation_gate():
         cirq.commutes(gate, cirq.CCZ)
 
 
-def test_validate_permutation_errors():
+def test_validate_permutation_errors() -> None:
     validate_permutation = cca.PermutationGate.validate_permutation
     validate_permutation({})
 
@@ -59,7 +60,7 @@ def test_validate_permutation_errors():
     assert cirq.circuit_diagram_info(gate, default=None) is None
 
 
-def test_diagram():
+def test_diagram() -> None:
     gate = cca.SwapPermutationGate()
     a, b = cirq.NamedQubit('a'), cirq.NamedQubit('b')
     circuit = cirq.Circuit([gate(a, b)])
@@ -72,17 +73,19 @@ def test_diagram():
     assert actual_text_diagram == expected_text_diagram
 
 
-def test_update_mapping():
+def test_update_mapping() -> None:
     gate = cca.SwapPermutationGate()
     a, b, c = (cirq.NamedQubit(s) for s in 'abc')
+    mapping: dict[cirq.Qid, int]
     mapping = {s: i for i, s in enumerate((a, b, c))}
     ops = [gate(a, b), gate(b, c)]
     cca.update_mapping(mapping, ops)
     assert mapping == {a: 1, b: 2, c: 0}
 
 
-def test_get_logical_operations():
+def test_get_logical_operations() -> None:
     a, b, c, d = qubits = cirq.LineQubit.range(4)
+    mapping: dict[cirq.Qid, cirq.Qid]
     mapping = dict(zip(qubits, qubits))
     operations = [
         cirq.ZZ(a, b),
@@ -106,7 +109,7 @@ def test_get_logical_operations():
         for n_elements in (random.randint(5, 20) for _ in range(20))
     ),
 )
-def test_linear_permutation_gate(n_elements, n_permuted):
+def test_linear_permutation_gate(n_elements, n_permuted) -> None:
     qubits = cirq.LineQubit.range(n_elements)
     elements = tuple(range(n_elements))
     elements_to_permute = random.sample(elements, n_permuted)
@@ -116,16 +119,18 @@ def test_linear_permutation_gate(n_elements, n_permuted):
     gate = cca.LinearPermutationGate(n_elements, permutation)
     ct.assert_equivalent_repr(gate)
     assert gate.permutation() == permutation
+    mapping: dict[cirq.Qid, int]
     mapping = dict(zip(qubits, elements))
     for swap in cirq.flatten_op_tree(cirq.decompose_once_with_qubits(gate, qubits)):
         assert isinstance(swap, cirq.GateOperation)
+        assert isinstance(swap.gate, cca.PermutationGate)
         swap.gate.update_mapping(mapping, swap.qubits)
     for i in range(n_elements):
         p = permutation.get(elements[i], i)
         assert mapping.get(qubits[p], elements[i]) == i
 
 
-def random_equal_permutations(n_perms, n_items, prob):
+def random_equal_permutations(n_perms, n_items, prob) -> list[dict[int, int]]:
     indices_to_permute = [i for i in range(n_items) if random.random() <= prob]
     permuted_indices = random.sample(indices_to_permute, len(indices_to_permute))
     base_permutation = dict(zip(indices_to_permute, permuted_indices))
@@ -138,7 +143,9 @@ def random_equal_permutations(n_perms, n_items, prob):
     return permutations
 
 
-def random_permutation_equality_groups(n_groups, n_perms_per_group, n_items, prob):
+def random_permutation_equality_groups(
+    n_groups, n_perms_per_group, n_items, prob
+) -> Iterator[list[dict[int, int]]]:
     fingerprints = set()
     for _ in range(n_groups):
         perms = random_equal_permutations(n_perms_per_group, n_items, prob)
@@ -150,7 +157,7 @@ def random_permutation_equality_groups(n_groups, n_perms_per_group, n_items, pro
 
 
 @pytest.mark.parametrize('permutation_sets', [random_permutation_equality_groups(5, 3, 10, 0.5)])
-def test_linear_permutation_gate_equality(permutation_sets):
+def test_linear_permutation_gate_equality(permutation_sets) -> None:
     swap_gates = [cirq.SWAP, cirq.CNOT]
     equals_tester = ct.EqualsTester()
     for swap_gate in swap_gates:
@@ -163,7 +170,7 @@ def test_linear_permutation_gate_equality(permutation_sets):
             )
 
 
-def test_linear_permutation_gate_pow_not_implemented():
+def test_linear_permutation_gate_pow_not_implemented() -> None:
     permutation_gate = cca.LinearPermutationGate(3, {0: 1, 1: 2, 2: 0})
 
     assert permutation_gate.__pow__(0) is NotImplemented
@@ -183,7 +190,7 @@ def test_linear_permutation_gate_pow_not_implemented():
         (4, {0: 3, 1: 2, 2: 1, 3: 0}),
     ],
 )
-def test_linear_permutation_gate_pow_identity(num_qubits, permutation):
+def test_linear_permutation_gate_pow_identity(num_qubits, permutation) -> None:
     permutation_gate = cca.LinearPermutationGate(num_qubits, permutation)
 
     assert permutation_gate**1 == permutation_gate
@@ -199,7 +206,7 @@ def test_linear_permutation_gate_pow_identity(num_qubits, permutation):
         (4, {0: 3, 1: 2, 2: 1, 3: 0}, {0: 3, 1: 2, 2: 1, 3: 0}),
     ],
 )
-def test_linear_permutation_gate_pow_inverse(num_qubits, permutation, inverse):
+def test_linear_permutation_gate_pow_inverse(num_qubits, permutation, inverse) -> None:
     permutation_gate = cca.LinearPermutationGate(num_qubits, permutation)
     inverse_gate = cca.LinearPermutationGate(num_qubits, inverse)
 
@@ -207,7 +214,7 @@ def test_linear_permutation_gate_pow_inverse(num_qubits, permutation, inverse):
     assert cirq.inverse(permutation_gate) == inverse_gate
 
 
-def test_display_mapping():
+def test_display_mapping() -> None:
     indices = [4, 2, 0, 1, 3]
     qubits = cirq.LineQubit.range(len(indices))
     circuit = cca.complete_acquaintance_strategy(qubits, 2)
@@ -238,7 +245,7 @@ def test_display_mapping():
         for _ in range(4)
     ],
 )
-def test_return_to_initial_mapping(circuit):
+def test_return_to_initial_mapping(circuit) -> None:
     qubits = sorted(circuit.all_qubits())
     cca.return_to_initial_mapping(circuit)
     initial_mapping = {q: i for i, q in enumerate(qubits)}
@@ -247,7 +254,7 @@ def test_return_to_initial_mapping(circuit):
     assert mapping == initial_mapping
 
 
-def test_uses_consistent_swap_gate():
+def test_uses_consistent_swap_gate() -> None:
     a, b = cirq.LineQubit.range(2)
     circuit = cirq.Circuit([cca.SwapPermutationGate()(a, b), cca.SwapPermutationGate()(a, b)])
     assert cca.uses_consistent_swap_gate(circuit, cirq.SWAP)
@@ -264,7 +271,7 @@ def test_uses_consistent_swap_gate():
     assert not cca.uses_consistent_swap_gate(circuit, cirq.CZ)
 
 
-def test_swap_gate_eq():
+def test_swap_gate_eq() -> None:
     assert cca.SwapPermutationGate() == cca.SwapPermutationGate(cirq.SWAP)
     assert cca.SwapPermutationGate() != cca.SwapPermutationGate(cirq.CZ)
     assert cca.SwapPermutationGate(cirq.CZ) == cca.SwapPermutationGate(cirq.CZ)
@@ -278,5 +285,5 @@ def test_swap_gate_eq():
         cca.SwapPermutationGate(cirq.CZ),
     ],
 )
-def test_swap_gate_repr(gate):
+def test_swap_gate_repr(gate) -> None:
     cirq.testing.assert_equivalent_repr(gate)
diff --git a/cirq-core/cirq/contrib/acquaintance/shift_swap_network_test.py b/cirq-core/cirq/contrib/acquaintance/shift_swap_network_test.py
index c5e38d6c795..acef3c2297d 100644
--- a/cirq-core/cirq/contrib/acquaintance/shift_swap_network_test.py
+++ b/cirq-core/cirq/contrib/acquaintance/shift_swap_network_test.py
@@ -23,7 +23,7 @@
 import cirq.contrib.acquaintance as cca
 
 
-def random_part_lens(max_n_parts, max_part_size):
+def random_part_lens(max_n_parts, max_part_size) -> tuple[int, ...]:
     return tuple(random.randint(1, max_part_size) for _ in range(random.randint(1, max_n_parts)))
 
 
@@ -31,7 +31,7 @@ def random_part_lens(max_n_parts, max_part_size):
     'left_part_lens,right_part_lens',
     [tuple(random_part_lens(7, 2) for _ in ('left', 'right')) for _ in range(5)],
 )
-def test_shift_swap_network_gate_acquaintance_opps(left_part_lens, right_part_lens):
+def test_shift_swap_network_gate_acquaintance_opps(left_part_lens, right_part_lens) -> None:
 
     gate = cca.ShiftSwapNetworkGate(left_part_lens, right_part_lens)
     n_qubits = gate.qubit_count()
@@ -45,6 +45,7 @@ def test_shift_swap_network_gate_acquaintance_opps(left_part_lens, right_part_le
     # expected opps
     i = 0
     sides = ('left', 'right')
+    parts: dict[str, list[set[int]]]
     parts = {side: [] for side in sides}
     for side, part_lens in zip(sides, (left_part_lens, right_part_lens)):
         for part_len in part_lens:
@@ -205,7 +206,7 @@ def test_shift_swap_network_gate_acquaintance_opps(left_part_lens, right_part_le
 
 
 @pytest.mark.parametrize('left_part_lens,right_part_lens', set(key[1:] for key in circuit_diagrams))
-def test_shift_swap_network_gate_diagrams(left_part_lens, right_part_lens):
+def test_shift_swap_network_gate_diagrams(left_part_lens, right_part_lens) -> None:
 
     gate = cca.ShiftSwapNetworkGate(left_part_lens, right_part_lens)
     n_qubits = gate.qubit_count()
@@ -220,7 +221,7 @@ def test_shift_swap_network_gate_diagrams(left_part_lens, right_part_lens):
     cirq.testing.assert_has_diagram(circuit, diagram)
 
 
-def test_shift_swap_network_gate_bad_part_lens():
+def test_shift_swap_network_gate_bad_part_lens() -> None:
     with pytest.raises(ValueError):
         cca.ShiftSwapNetworkGate((0, 1, 1), (2, 2))
     with pytest.raises(ValueError):
@@ -235,7 +236,7 @@ def test_shift_swap_network_gate_bad_part_lens():
     'left_part_lens,right_part_lens',
     [tuple(random_part_lens(2, 2) for _ in ('left', 'right')) for _ in range(5)],
 )
-def test_shift_swap_network_gate_repr(left_part_lens, right_part_lens):
+def test_shift_swap_network_gate_repr(left_part_lens, right_part_lens) -> None:
     gate = cca.ShiftSwapNetworkGate(left_part_lens, right_part_lens)
     cirq.testing.assert_equivalent_repr(gate)
 
@@ -247,7 +248,7 @@ def test_shift_swap_network_gate_repr(left_part_lens, right_part_lens):
     'left_part_lens,right_part_lens',
     [tuple(random_part_lens(2, 2) for _ in ('left', 'right')) for _ in range(5)],
 )
-def test_shift_swap_network_gate_permutation(left_part_lens, right_part_lens):
+def test_shift_swap_network_gate_permutation(left_part_lens, right_part_lens) -> None:
     gate = cca.ShiftSwapNetworkGate(left_part_lens, right_part_lens)
     n_qubits = gate.qubit_count()
     cca.testing.assert_permutation_decomposition_equivalence(gate, n_qubits)
diff --git a/cirq-core/cirq/contrib/acquaintance/strategies/quartic_paired_test.py b/cirq-core/cirq/contrib/acquaintance/strategies/quartic_paired_test.py
index 18c9149de7e..6a8385524c4 100644
--- a/cirq-core/cirq/contrib/acquaintance/strategies/quartic_paired_test.py
+++ b/cirq-core/cirq/contrib/acquaintance/strategies/quartic_paired_test.py
@@ -16,6 +16,7 @@
 
 import itertools
 import random
+from typing import Iterable
 
 import pytest
 
@@ -23,27 +24,28 @@
 import cirq.contrib.acquaintance as cca
 
 
-def test_bad_qubit_pairs():
+def test_bad_qubit_pairs() -> None:
     a, b, c, d, e = cirq.LineQubit.range(5)
     bad_qubit_pairs = [(a, b), (c, d), (e,)]
     with pytest.raises(ValueError):
         cca.strategies.quartic_paired.qubit_pairs_to_qubit_order(bad_qubit_pairs)
 
 
-def random_index_pairs(n_pairs: int):
+def random_index_pairs(n_pairs: int) -> tuple[tuple[int, int], ...]:
     indices = list(range(2 * n_pairs))
     random.shuffle(indices)
-    return tuple(indices[2 * i : 2 * (i + 1)] for i in range(n_pairs))
+    return tuple(zip(indices[0::2], indices[1::2]))
 
 
 @pytest.mark.parametrize(
     'index_pairs', [random_index_pairs(n_pairs) for n_pairs in range(2, 7) for _ in range(2)]
 )
-def test_quartic_paired_acquaintances(index_pairs):
+def test_quartic_paired_acquaintances(index_pairs) -> None:
     n_pairs = len(index_pairs)
-    qubit_pairs = tuple(tuple(cirq.LineQubit(x) for x in index_pair) for index_pair in index_pairs)
+    qubit_pairs: Iterable[tuple[cirq.Qid, cirq.Qid]]
+    qubit_pairs = tuple((cirq.LineQubit(x), cirq.LineQubit(y)) for x, y in index_pairs)
     strategy, qubits = cca.quartic_paired_acquaintance_strategy(qubit_pairs)
-    initial_mapping = {q: q.x for q in qubits}
+    initial_mapping = {q: q.x for q in qubits}  # type: ignore[attr-defined]
     opps = cca.get_logical_acquaintance_opportunities(strategy, initial_mapping)
     assert set(len(opp) for opp in opps) == set([2, 4])
     quadratic_opps = set(opp for opp in opps if len(opp) == 2)
diff --git a/cirq-core/cirq/contrib/bayesian_network/bayesian_network_gate.py b/cirq-core/cirq/contrib/bayesian_network/bayesian_network_gate.py
index 90fac003093..1e99985ec99 100644
--- a/cirq-core/cirq/contrib/bayesian_network/bayesian_network_gate.py
+++ b/cirq-core/cirq/contrib/bayesian_network/bayesian_network_gate.py
@@ -97,7 +97,7 @@ class BayesianNetworkGate(raw_types.Gate):
     def __init__(
         self,
         init_probs: list[tuple[str, float | None]],
-        arc_probs: list[tuple[str, tuple[str], list[float]]],
+        arc_probs: list[tuple[str, tuple[str, ...], list[float]]],
     ):
         """Builds a BayesianNetworkGate.
 
@@ -195,7 +195,7 @@ def _from_json_dict_(
             list[tuple[str, float | None]], [(param, init_prob) for param, init_prob in init_probs]
         )
         converted_cond_probs = cast(
-            list[tuple[str, tuple[str], list[float]]],
+            list[tuple[str, tuple[str, ...], list[float]]],
             [(target, tuple(params), cond_probs) for target, params, cond_probs in arc_probs],
         )
         return cls(converted_init_probs, converted_cond_probs)
diff --git a/cirq-core/cirq/contrib/bayesian_network/bayesian_network_gate_test.py b/cirq-core/cirq/contrib/bayesian_network/bayesian_network_gate_test.py
index 7e3a72ff46d..7c9824be545 100644
--- a/cirq-core/cirq/contrib/bayesian_network/bayesian_network_gate_test.py
+++ b/cirq-core/cirq/contrib/bayesian_network/bayesian_network_gate_test.py
@@ -21,14 +21,14 @@
 import cirq.contrib.bayesian_network as ccb
 
 
-def test_basic_properties():
+def test_basic_properties() -> None:
     gate = ccb.BayesianNetworkGate([('q0', None), ('q1', None), ('q2', None)], [])
 
     assert gate._has_unitary_()
     assert gate._qid_shape_() == (2, 2, 2)
 
 
-def test_incorrect_constructor():
+def test_incorrect_constructor() -> None:
     # Success building.
     ccb.BayesianNetworkGate([('q0', 0.0), ('q1', None)], [('q1', ('q0',), [0.0, 0.0])])
 
@@ -37,7 +37,9 @@ def test_incorrect_constructor():
 
     # This is an easy mistake where the tuple for q0 doesn't have the comma at the end.
     with pytest.raises(ValueError, match='Conditional prob params must be a tuple.'):
-        ccb.BayesianNetworkGate([('q0', 0.0), ('q1', None)], [('q1', ('q0'), [0.0, 0.0])])
+        ccb.BayesianNetworkGate(
+            [('q0', 0.0), ('q1', None)], [('q1', ('q0'), [0.0, 0.0])]  # type: ignore
+        )
 
     with pytest.raises(ValueError, match='Incorrect number of conditional probs.'):
         ccb.BayesianNetworkGate([('q0', 0.0), ('q1', None)], [('q1', ('q0',), [0.0])])
@@ -46,7 +48,7 @@ def test_incorrect_constructor():
         ccb.BayesianNetworkGate([('q0', 0.0), ('q1', None)], [('q1', ('q0',), [2016.0913, 0.0])])
 
 
-def test_repr():
+def test_repr() -> None:
     gate = ccb.BayesianNetworkGate([('q0', 0.0), ('q1', None)], [('q1', ('q0',), [0.0, 0.0])])
 
     assert repr(gate) == (
@@ -56,7 +58,7 @@ def test_repr():
 
 
 @pytest.mark.parametrize('input_prob', [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0])
-def test_prob_encoding(input_prob):
+def test_prob_encoding(input_prob) -> None:
     q = cirq.NamedQubit('q')
     gate = ccb.BayesianNetworkGate([('q', input_prob)], [])
     circuit = cirq.Circuit(gate.on(q))
@@ -82,7 +84,7 @@ def test_prob_encoding(input_prob):
     ],
 )
 @pytest.mark.parametrize('decompose', [True, False])
-def test_initial_probs(p0, p1, p2, expected_probs, decompose):
+def test_initial_probs(p0, p1, p2, expected_probs, decompose) -> None:
     q0, q1, q2 = cirq.LineQubit.range(3)
     gate = ccb.BayesianNetworkGate([('q0', p0), ('q1', p1), ('q2', p2)], [])
     if decompose:
@@ -102,7 +104,7 @@ def test_initial_probs(p0, p1, p2, expected_probs, decompose):
     [(0.0, 0.0, 0.1), (0.0, 1.0, 0.2), (1.0, 0.0, 0.3), (1.0, 1.0, 0.4)],
 )
 @pytest.mark.parametrize('decompose', [True, False])
-def test_arc_probs(input_prob_q0, input_prob_q1, expected_prob_q2, decompose):
+def test_arc_probs(input_prob_q0, input_prob_q1, expected_prob_q2, decompose) -> None:
     q0, q1, q2 = cirq.LineQubit.range(3)
     gate = ccb.BayesianNetworkGate(
         [('q0', input_prob_q0), ('q1', input_prob_q1), ('q2', None)],
@@ -122,7 +124,7 @@ def test_arc_probs(input_prob_q0, input_prob_q1, expected_prob_q2, decompose):
     np.testing.assert_almost_equal(actual_prob_q2_is_one, expected_prob_q2, decimal=4)
 
 
-def test_repro_figure_10_of_paper():
+def test_repro_figure_10_of_paper() -> None:
     # We try to create the network of figure 10 and check that the probabilities are the same as
     # the ones in table 10 of https://arxiv.org/abs/2004.14803.
     ir = cirq.NamedQubit('q4_IR')
diff --git a/cirq-core/cirq/contrib/circuitdag/circuit_dag.py b/cirq-core/cirq/contrib/circuitdag/circuit_dag.py
index 75c5a7b5c47..f270979cdc1 100644
--- a/cirq-core/cirq/contrib/circuitdag/circuit_dag.py
+++ b/cirq-core/cirq/contrib/circuitdag/circuit_dag.py
@@ -44,7 +44,7 @@ def __init__(self, val: T) -> None:
     def __repr__(self) -> str:
         return f'cirq.contrib.Unique({id(self)}, {self.val!r})'
 
-    def __lt__(self, other):
+    def __lt__(self, other) -> bool:
         if not isinstance(other, type(self)):
             return NotImplemented
         return id(self) < id(other)
@@ -176,7 +176,7 @@ def get_next_node(succ: networkx.classes.coreviews.AtlasView) -> Unique[cirq.Ope
     def all_operations(self) -> Iterator[cirq.Operation]:
         return (node.val for node in self.ordered_nodes())
 
-    def all_qubits(self):
+    def all_qubits(self) -> frozenset[cirq.Qid]:
         return frozenset(q for node in self.nodes for q in node.val.qubits)
 
     def to_circuit(self) -> cirq.Circuit:
diff --git a/cirq-core/cirq/contrib/circuitdag/circuit_dag_test.py b/cirq-core/cirq/contrib/circuitdag/circuit_dag_test.py
index 49b13b767e0..f260b96f926 100644
--- a/cirq-core/cirq/contrib/circuitdag/circuit_dag_test.py
+++ b/cirq-core/cirq/contrib/circuitdag/circuit_dag_test.py
@@ -27,7 +27,7 @@ class FakeDevice(cirq.Device):
     pass
 
 
-def test_wrapper_eq():
+def test_wrapper_eq() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     eq = cirq.testing.EqualsTester()
     eq.add_equality_group(cirq.contrib.CircuitDag.make_node(cirq.X(q0)))
@@ -36,7 +36,7 @@ def test_wrapper_eq():
     eq.add_equality_group(cirq.contrib.CircuitDag.make_node(cirq.X(q1)))
 
 
-def test_wrapper_cmp():
+def test_wrapper_cmp() -> None:
     u0 = cirq.contrib.Unique(0)
     u1 = cirq.contrib.Unique(1)
     # The ordering of Unique instances is unpredictable
@@ -51,14 +51,14 @@ def test_wrapper_cmp():
     assert u1 >= u0
 
 
-def test_wrapper_cmp_failure():
+def test_wrapper_cmp_failure() -> None:
     with pytest.raises(TypeError):
         _ = object() < cirq.contrib.Unique(1)
     with pytest.raises(TypeError):
         _ = cirq.contrib.Unique(1) < object()
 
 
-def test_wrapper_repr():
+def test_wrapper_repr() -> None:
     q0 = cirq.LineQubit(0)
 
     node = cirq.contrib.CircuitDag.make_node(cirq.X(q0))
@@ -66,14 +66,14 @@ def test_wrapper_repr():
     assert repr(node) == expected
 
 
-def test_init():
+def test_init() -> None:
     dag = cirq.contrib.CircuitDag()
     assert networkx.dag.is_directed_acyclic_graph(dag)
     assert list(dag.nodes()) == []
     assert list(dag.edges()) == []
 
 
-def test_append():
+def test_append() -> None:
     q0 = cirq.LineQubit(0)
     dag = cirq.contrib.CircuitDag()
     dag.append(cirq.X(q0))
@@ -83,7 +83,7 @@ def test_append():
     assert [(n1.val, n2.val) for n1, n2 in dag.edges()] == [(cirq.X(q0), cirq.Y(q0))]
 
 
-def test_two_identical_ops():
+def test_two_identical_ops() -> None:
     q0 = cirq.LineQubit(0)
     dag = cirq.contrib.CircuitDag()
     dag.append(cirq.X(q0))
@@ -98,7 +98,7 @@ def test_two_identical_ops():
     }
 
 
-def test_from_ops():
+def test_from_ops() -> None:
     q0 = cirq.LineQubit(0)
     dag = cirq.contrib.CircuitDag.from_ops(cirq.X(q0), cirq.Y(q0))
     assert networkx.dag.is_directed_acyclic_graph(dag)
@@ -106,7 +106,7 @@ def test_from_ops():
     assert [(n1.val, n2.val) for n1, n2 in dag.edges()] == [(cirq.X(q0), cirq.Y(q0))]
 
 
-def test_from_circuit():
+def test_from_circuit() -> None:
     q0 = cirq.LineQubit(0)
     circuit = cirq.Circuit(cirq.X(q0), cirq.Y(q0))
     dag = cirq.contrib.CircuitDag.from_circuit(circuit)
@@ -116,14 +116,14 @@ def test_from_circuit():
     assert sorted(circuit.all_qubits()) == sorted(dag.all_qubits())
 
 
-def test_to_empty_circuit():
+def test_to_empty_circuit() -> None:
     circuit = cirq.Circuit()
     dag = cirq.contrib.CircuitDag.from_circuit(circuit)
     assert networkx.dag.is_directed_acyclic_graph(dag)
     assert circuit == dag.to_circuit()
 
 
-def test_to_circuit():
+def test_to_circuit() -> None:
     q0 = cirq.LineQubit(0)
     circuit = cirq.Circuit(cirq.X(q0), cirq.Y(q0))
     dag = cirq.contrib.CircuitDag.from_circuit(circuit)
@@ -137,7 +137,7 @@ def test_to_circuit():
     )
 
 
-def test_equality():
+def test_equality() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     circuit1 = cirq.Circuit(
         cirq.X(q0), cirq.Y(q0), cirq.Z(q1), cirq.CZ(q0, q1), cirq.X(q1), cirq.Y(q1), cirq.Z(q0)
@@ -167,7 +167,7 @@ def test_equality():
     eq.add_equality_group(cirq.contrib.CircuitDag.from_circuit(circuit4))
 
 
-def test_larger_circuit():
+def test_larger_circuit() -> None:
     q0, q1, q2, q3 = [
         cirq.GridQubit(0, 5),
         cirq.GridQubit(1, 5),
@@ -213,7 +213,7 @@ def test_larger_circuit():
 
 
 @pytest.mark.parametrize('circuit', [cirq.testing.random_circuit(10, 10, 0.5) for _ in range(3)])
-def test_is_maximalist(circuit):
+def test_is_maximalist(circuit) -> None:
     dag = cirq.contrib.CircuitDag.from_circuit(circuit)
     transitive_closure = networkx.dag.transitive_closure(dag)
     assert cirq.contrib.CircuitDag(incoming_graph_data=transitive_closure) == dag
@@ -232,7 +232,7 @@ def _get_circuits_and_is_blockers():
 
 
 @pytest.mark.parametrize('circuit, is_blocker', _get_circuits_and_is_blockers())
-def test_findall_nodes_until_blocked(circuit, is_blocker):
+def test_findall_nodes_until_blocked(circuit, is_blocker) -> None:
     dag = cirq.contrib.CircuitDag.from_circuit(circuit)
     all_nodes = list(dag.ordered_nodes())
     found_nodes = list(dag.findall_nodes_until_blocked(is_blocker))
diff --git a/cirq-core/cirq/contrib/custom_simulators/custom_state_simulator_test.py b/cirq-core/cirq/contrib/custom_simulators/custom_state_simulator_test.py
index bc57309489a..dc87c32528d 100644
--- a/cirq-core/cirq/contrib/custom_simulators/custom_state_simulator_test.py
+++ b/cirq-core/cirq/contrib/custom_simulators/custom_state_simulator_test.py
@@ -30,7 +30,9 @@ def __init__(self, initial_state: list[int]):
     def copy(self, deep_copy_buffers: bool = True) -> ComputationalBasisState:
         return ComputationalBasisState(self.basis)  # pragma: no cover
 
-    def measure(self, axes: Sequence[int], seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None):
+    def measure(
+        self, axes: Sequence[int], seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None
+    ) -> list[int]:
         return [self.basis[i] for i in axes]
 
 
@@ -49,7 +51,7 @@ def _act_on_fallback_(self, action, qubits: Sequence[cirq.Qid], allow_decompose:
             return True
 
 
-def create_test_circuit():
+def create_test_circuit() -> cirq.Circuit:
     q0, q1 = cirq.LineQid.range(2, dimension=3)
     x = cirq.XPowGate(dimension=3)
     return cirq.Circuit(
@@ -143,7 +145,9 @@ def __init__(self, initial_state: list[int]):
     def copy(self, deep_copy_buffers: bool = True) -> ComputationalBasisProductState:
         return ComputationalBasisProductState(self.basis)
 
-    def measure(self, axes: Sequence[int], seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None):
+    def measure(
+        self, axes: Sequence[int], seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None
+    ) -> list[int]:
         return [self.basis[i] for i in axes]
 
     def kron(self, other: ComputationalBasisProductState) -> ComputationalBasisProductState:
diff --git a/cirq-core/cirq/contrib/graph_device/graph_device.py b/cirq-core/cirq/contrib/graph_device/graph_device.py
index 6041d990ae6..4fe54d0ad7b 100644
--- a/cirq-core/cirq/contrib/graph_device/graph_device.py
+++ b/cirq-core/cirq/contrib/graph_device/graph_device.py
@@ -16,7 +16,7 @@
 
 import abc
 import itertools
-from typing import cast, Iterable, TYPE_CHECKING
+from typing import Any, cast, Hashable, Iterable, NoReturn, TYPE_CHECKING
 
 from cirq import devices, ops, value
 from cirq.contrib.graph_device.hypergraph import UndirectedHypergraph
@@ -98,7 +98,7 @@ def is_crosstalk_graph(graph: UndirectedHypergraph) -> bool:
     return True
 
 
-def raise_crosstalk_error(*ops: ops.Operation):
+def raise_crosstalk_error(*ops: ops.Operation) -> NoReturn:
     raise ValueError(f'crosstalk on {ops}')
 
 
@@ -156,11 +156,11 @@ def qubits(self) -> tuple[cirq.Qid, ...]:
         return cast(tuple['cirq.Qid', ...], tuple(sorted(self.device_graph.vertices)))
 
     @property
-    def edges(self):
+    def edges(self) -> tuple[frozenset[Hashable], ...]:
         return tuple(sorted(self.device_graph.edges))
 
     @property
-    def labelled_edges(self):
+    def labelled_edges(self) -> dict[frozenset, Any]:
         return self.device_graph.labelled_edges
 
     def get_device_edge_from_op(self, operation: ops.Operation) -> UndirectedGraphDeviceEdge:
@@ -185,6 +185,7 @@ def validate_crosstalk(
             self.crosstalk_graph._adjacency_lists.get(frozenset(operation.qubits), ())
         )
         for crosstalk_edge in adjacent_crosstalk_edges:
+            # pylint: disable=unreachable
             label = self.crosstalk_graph.labelled_edges[crosstalk_edge]
             validator = (
                 raise_crosstalk_error(operation, *other_operations) if (label is None) else label
@@ -194,7 +195,7 @@ def validate_crosstalk(
             ):
                 validator(operation, *crosstalk_operations)
 
-    def validate_moment(self, moment: cirq.Moment):
+    def validate_moment(self, moment: cirq.Moment) -> None:
         super().validate_moment(moment)
         ops = moment.operations
         for i, op in enumerate(ops):
diff --git a/cirq-core/cirq/contrib/graph_device/graph_device_test.py b/cirq-core/cirq/contrib/graph_device/graph_device_test.py
index bb1dd0acfad..54915e4b005 100644
--- a/cirq-core/cirq/contrib/graph_device/graph_device_test.py
+++ b/cirq-core/cirq/contrib/graph_device/graph_device_test.py
@@ -14,6 +14,8 @@
 
 from __future__ import annotations
 
+from typing import Any, Hashable, Iterable
+
 import pytest
 
 import cirq
@@ -21,7 +23,7 @@
 import cirq.contrib.graph_device.graph_device as ccgdgd
 
 
-def test_fixed_duration_undirected_graph_device_edge_eq():
+def test_fixed_duration_undirected_graph_device_edge_eq() -> None:
     e = ccgd.FixedDurationUndirectedGraphDeviceEdge(cirq.Duration(picos=4))
     f = ccgd.FixedDurationUndirectedGraphDeviceEdge(cirq.Duration(picos=4))
     g = ccgd.FixedDurationUndirectedGraphDeviceEdge(cirq.Duration(picos=5))
@@ -30,15 +32,15 @@ def test_fixed_duration_undirected_graph_device_edge_eq():
     assert e != 4
 
 
-def test_unconstrained_undirected_graph_device_edge_eq():
+def test_unconstrained_undirected_graph_device_edge_eq() -> None:
     e = ccgdgd._UnconstrainedUndirectedGraphDeviceEdge()
     f = ccgd.UnconstrainedUndirectedGraphDeviceEdge
     assert e == f
     assert e != 3
 
 
-def test_is_undirected_device_graph():
-    assert not ccgd.is_undirected_device_graph('abc')
+def test_is_undirected_device_graph() -> None:
+    assert not ccgd.is_undirected_device_graph('abc')  # type: ignore[arg-type]
     graph = ccgd.UndirectedHypergraph()
     assert ccgd.is_undirected_device_graph(graph)
     a, b, c, d, e = cirq.LineQubit.range(5)
@@ -52,9 +54,9 @@ def test_is_undirected_device_graph():
     assert not ccgd.is_undirected_device_graph(graph)
 
 
-def test_is_crosstalk_graph():
+def test_is_crosstalk_graph() -> None:
     a, b, c, d, e, f = cirq.LineQubit.range(6)
-    assert not ccgd.is_crosstalk_graph('abc')
+    assert not ccgd.is_crosstalk_graph('abc')  # type: ignore[arg-type]
     graph = ccgd.UndirectedHypergraph()
     graph.add_vertex('abc')
     assert not ccgd.is_crosstalk_graph(graph)
@@ -76,14 +78,14 @@ def test_is_crosstalk_graph():
     assert not ccgd.is_crosstalk_graph(graph)
 
 
-def test_unconstrained_undirected_graph_device_edge():
+def test_unconstrained_undirected_graph_device_edge() -> None:
     edge = ccgd.UnconstrainedUndirectedGraphDeviceEdge
     qubits = cirq.LineQubit.range(2)
     assert edge.duration_of(cirq.X(qubits[0])) == cirq.Duration(picos=0)
     assert edge.duration_of(cirq.CZ(*qubits[:2])) == cirq.Duration(picos=0)
 
 
-def test_graph_device():
+def test_graph_device() -> None:
     one_qubit_duration = cirq.Duration(picos=10)
     two_qubit_duration = cirq.Duration(picos=1)
     one_qubit_edge = ccgd.FixedDurationUndirectedGraphDeviceEdge(one_qubit_duration)
@@ -95,7 +97,7 @@ def test_graph_device():
 
     n_qubits = 4
     qubits = cirq.LineQubit.range(n_qubits)
-    edges = {
+    edges: dict[Iterable[Hashable], Any] = {
         (cirq.LineQubit(i), cirq.LineQubit((i + 1) % n_qubits)): two_qubit_edge
         for i in range(n_qubits)
     }
@@ -111,8 +113,8 @@ def not_cnots(first_op, second_op):
 
     assert ccgd.is_undirected_device_graph(device_graph)
     with pytest.raises(TypeError):
-        ccgd.UndirectedGraphDevice('abc')
-    constraint_edges = {
+        ccgd.UndirectedGraphDevice('abc')  # type: ignore[arg-type]
+    constraint_edges: dict[Iterable[Hashable], Any] = {
         (frozenset(cirq.LineQubit.range(2)), frozenset(cirq.LineQubit.range(2, 4))): None,
         (
             frozenset(cirq.LineQubit.range(1, 3)),
@@ -123,7 +125,7 @@ def not_cnots(first_op, second_op):
     assert ccgd.is_crosstalk_graph(crosstalk_graph)
 
     with pytest.raises(TypeError):
-        ccgd.UndirectedGraphDevice(device_graph, crosstalk_graph='abc')
+        ccgd.UndirectedGraphDevice(device_graph, crosstalk_graph='abc')  # type: ignore[arg-type]
 
     graph_device = ccgd.UndirectedGraphDevice(device_graph)
     assert graph_device.crosstalk_graph == ccgd.UndirectedHypergraph()
@@ -141,7 +143,7 @@ def not_cnots(first_op, second_op):
     with pytest.raises(ValueError):
         graph_device.validate_operation(cirq.CNOT(qubits[0], qubits[2]))
     with pytest.raises(AttributeError):
-        graph_device.validate_operation(list((2, 3)))
+        graph_device.validate_operation(list((2, 3)))  # type: ignore[arg-type]
 
     moment = cirq.Moment([cirq.CNOT(*qubits[:2]), cirq.CNOT(*qubits[2:])])
     with pytest.raises(ValueError):
@@ -155,7 +157,7 @@ def not_cnots(first_op, second_op):
         graph_device.validate_moment(moment)
 
 
-def test_graph_device_copy_and_add():
+def test_graph_device_copy_and_add() -> None:
     a, b, c, d, e, f = cirq.LineQubit.range(6)
     device_graph = ccgd.UndirectedHypergraph(labelled_edges={(a, b): None, (c, d): None})
     crosstalk_graph = ccgd.UndirectedHypergraph(
diff --git a/cirq-core/cirq/contrib/graph_device/hypergraph.py b/cirq-core/cirq/contrib/graph_device/hypergraph.py
index 85b74a9033a..bd75c7036b9 100644
--- a/cirq-core/cirq/contrib/graph_device/hypergraph.py
+++ b/cirq-core/cirq/contrib/graph_device/hypergraph.py
@@ -71,7 +71,7 @@ def remove_vertex(self, vertex: Hashable) -> None:
                 self._adjacency_lists[neighbor].difference_update((edge,))
         del self._adjacency_lists[vertex]
 
-    def remove_vertices(self, vertices):
+    def remove_vertices(self, vertices) -> None:
         for vertex in vertices:
             self.remove_vertex(vertex)
 
@@ -82,7 +82,7 @@ def add_edge(self, vertices: Iterable[Hashable], label: Any = None) -> None:
             self._adjacency_lists[vertex].update((vertices,))
         self._labelled_edges[vertices] = label
 
-    def add_edges(self, edges: dict[Iterable[Hashable], Any]):
+    def add_edges(self, edges: dict[Iterable[Hashable], Any]) -> None:
         for vertices, label in edges.items():
             self.add_edge(vertices, label)
 
diff --git a/cirq-core/cirq/contrib/graph_device/hypergraph_test.py b/cirq-core/cirq/contrib/graph_device/hypergraph_test.py
index b16366fdc26..50a0f772511 100644
--- a/cirq-core/cirq/contrib/graph_device/hypergraph_test.py
+++ b/cirq-core/cirq/contrib/graph_device/hypergraph_test.py
@@ -21,7 +21,7 @@
 import cirq.contrib.graph_device as ccgd
 
 
-def test_update_edge_label():
+def test_update_edge_label() -> None:
     edge = frozenset(range(3))
     graph = ccgd.UndirectedHypergraph(labelled_edges={edge: 'a'})
     assert graph.labelled_edges[edge] == 'a'
@@ -29,7 +29,7 @@ def test_update_edge_label():
     assert graph.labelled_edges[edge] == 'b'
 
 
-def test_hypergraph():
+def test_hypergraph() -> None:
     vertices = range(4)
     graph = ccgd.UndirectedHypergraph(vertices=vertices)
     assert graph.vertices == tuple(vertices)
@@ -55,7 +55,7 @@ def test_hypergraph():
         for _ in range(10)
     ],
 )
-def test_eq(vertices, edges):
+def test_eq(vertices, edges) -> None:
     vertices = set(vertices).union(*edges)
     graph_initialized = ccgd.UndirectedHypergraph(vertices=vertices, labelled_edges=edges)
     graph_added_parallel = ccgd.UndirectedHypergraph()
@@ -69,15 +69,15 @@ def test_eq(vertices, edges):
     assert graph_initialized == graph_added_parallel == graph_added_sequential
 
 
-def test_random_hypergraph():
+def test_random_hypergraph() -> None:
     n_vertices = 4
     graph = ccgd.UndirectedHypergraph.random(n_vertices, {1: 1.0})
-    assert sorted(graph.vertices) == sorted(range(n_vertices))
+    assert sorted(graph.vertices) == sorted(range(n_vertices))  # type: ignore[type-var]
     assert set(graph.labelled_edges.values()) == set((None,))
     assert tuple(len(edge) for edge in graph.edges) == (1,) * n_vertices
 
 
-def test_copy():
+def test_copy() -> None:
     graph_original = ccgd.UndirectedHypergraph(labelled_edges={(0, 1): None})
     graph_copy = graph_original.__copy__()
     assert graph_copy == graph_original
@@ -85,20 +85,20 @@ def test_copy():
     assert graph_copy != graph_original
 
 
-def test_iadd():
+def test_iadd() -> None:
     graph = ccgd.UndirectedHypergraph(labelled_edges={(0, 1): None})
     addend = ccgd.UndirectedHypergraph(labelled_edges={(1, 2): None})
     graph += addend
     assert set(graph.edges) == set(frozenset(e) for e in ((0, 1), (1, 2)))
-    assert sorted(graph.vertices) == [0, 1, 2]
+    assert sorted(graph.vertices) == [0, 1, 2]  # type: ignore[type-var]
 
 
-def test_add():
+def test_add() -> None:
     first_addend = ccgd.UndirectedHypergraph(labelled_edges={('a', 'b'): None})
     second_addend = ccgd.UndirectedHypergraph(labelled_edges={('c', 'b'): None})
     graph_sum = first_addend + second_addend
-    assert sorted(first_addend.vertices) == list('ab')
-    assert sorted(second_addend.vertices) == list('bc')
+    assert sorted(first_addend.vertices) == list('ab')  # type: ignore[type-var]
+    assert sorted(second_addend.vertices) == list('bc')  # type: ignore[type-var]
     assert sorted(graph_sum.vertices) == list('abc')
     assert sorted(first_addend.edges) == [frozenset('ab')]
     assert sorted(second_addend.edges) == [frozenset('bc')]
diff --git a/cirq-core/cirq/contrib/graph_device/uniform_graph_device_test.py b/cirq-core/cirq/contrib/graph_device/uniform_graph_device_test.py
index 61a6963d6bb..c2271ef1e4a 100644
--- a/cirq-core/cirq/contrib/graph_device/uniform_graph_device_test.py
+++ b/cirq-core/cirq/contrib/graph_device/uniform_graph_device_test.py
@@ -14,21 +14,27 @@
 
 from __future__ import annotations
 
+from typing import TYPE_CHECKING
+
 import pytest
 
 import cirq
 import cirq.contrib.graph_device as ccgd
 
+if TYPE_CHECKING:
+    from cirq.contrib.graph_device.graph_device import UndirectedGraphDeviceEdge
+
 
-def test_empty_uniform_undirected_linear_device():
+def test_empty_uniform_undirected_linear_device() -> None:
     n_qubits = 4
+    edge_labels: dict[int, UndirectedGraphDeviceEdge | None]
     edge_labels = {}
     device = ccgd.uniform_undirected_linear_device(n_qubits, edge_labels)
     assert device.qubits == tuple()
     assert device.edges == tuple()
 
 
-def test_negative_arity_arg_uniform_undirected_linear_device():
+def test_negative_arity_arg_uniform_undirected_linear_device() -> None:
     with pytest.raises(ValueError):
         ccgd.uniform_undirected_linear_device(5, {-1: None})
     with pytest.raises(ValueError):
@@ -36,7 +42,7 @@ def test_negative_arity_arg_uniform_undirected_linear_device():
 
 
 @pytest.mark.parametrize('arity', range(1, 5))
-def test_regular_uniform_undirected_linear_device(arity):
+def test_regular_uniform_undirected_linear_device(arity) -> None:
     n_qubits = 10
     edge_labels = {arity: None}
     device = ccgd.uniform_undirected_linear_device(n_qubits, edge_labels)
diff --git a/cirq-core/cirq/contrib/hacks/disable_validation.py b/cirq-core/cirq/contrib/hacks/disable_validation.py
index 4380f853be9..68c37275585 100644
--- a/cirq-core/cirq/contrib/hacks/disable_validation.py
+++ b/cirq-core/cirq/contrib/hacks/disable_validation.py
@@ -17,10 +17,13 @@
 from __future__ import annotations
 
 import contextlib
+from collections.abc import Generator
 
 
 @contextlib.contextmanager
-def disable_op_validation(*, accept_debug_responsibility: bool = False):
+def disable_op_validation(
+    *, accept_debug_responsibility: bool = False
+) -> Generator[None, None, None]:
     if not accept_debug_responsibility:
         raise ValueError(
             "WARNING! Using disable_op_validation with invalid ops can cause "
diff --git a/cirq-core/cirq/contrib/json.py b/cirq-core/cirq/contrib/json.py
index 683ce4a3f35..e2503b6d473 100644
--- a/cirq-core/cirq/contrib/json.py
+++ b/cirq-core/cirq/contrib/json.py
@@ -3,10 +3,10 @@
 
 from __future__ import annotations
 
-from cirq.protocols.json_serialization import DEFAULT_RESOLVERS
+from cirq.protocols.json_serialization import DEFAULT_RESOLVERS, ObjectFactory
 
 
-def contrib_class_resolver(cirq_type: str):
+def contrib_class_resolver(cirq_type: str) -> ObjectFactory | None:
     """Extend cirq's JSON API with resolvers for cirq contrib classes."""
     from cirq.contrib.acquaintance import SwapPermutationGate
     from cirq.contrib.bayesian_network import BayesianNetworkGate
diff --git a/cirq-core/cirq/contrib/noise_models/noise_models.py b/cirq-core/cirq/contrib/noise_models/noise_models.py
index 6fb8df7ec7f..7c934cfde53 100644
--- a/cirq-core/cirq/contrib/noise_models/noise_models.py
+++ b/cirq-core/cirq/contrib/noise_models/noise_models.py
@@ -42,7 +42,7 @@ def __init__(self, depol_prob: float, prepend: bool = False):
         self.qubit_noise_gate = ops.DepolarizingChannel(depol_prob)
         self._prepend = prepend
 
-    def noisy_moment(self, moment: cirq.Moment, system_qubits: Sequence[cirq.Qid]):
+    def noisy_moment(self, moment: cirq.Moment, system_qubits: Sequence[cirq.Qid]) -> cirq.OP_TREE:
         if validate_all_measurements(moment) or self.is_virtual_moment(moment):  # pragma: no cover
             return moment
 
@@ -78,7 +78,7 @@ def __init__(self, bitflip_prob: float, prepend: bool = True):
         self.readout_noise_gate = ops.BitFlipChannel(bitflip_prob)
         self._prepend = prepend
 
-    def noisy_moment(self, moment: cirq.Moment, system_qubits: Sequence[cirq.Qid]):
+    def noisy_moment(self, moment: cirq.Moment, system_qubits: Sequence[cirq.Qid]) -> cirq.OP_TREE:
         if self.is_virtual_moment(moment):
             return moment
         if validate_all_measurements(moment):
@@ -115,7 +115,7 @@ def __init__(self, decay_prob: float, prepend: bool = True):
         self.readout_decay_gate = ops.AmplitudeDampingChannel(decay_prob)
         self._prepend = prepend
 
-    def noisy_moment(self, moment: cirq.Moment, system_qubits: Sequence[cirq.Qid]):
+    def noisy_moment(self, moment: cirq.Moment, system_qubits: Sequence[cirq.Qid]) -> cirq.OP_TREE:
         if self.is_virtual_moment(moment):
             return moment
         if validate_all_measurements(moment):
@@ -148,7 +148,7 @@ def __init__(self, depol_prob: float, bitflip_prob: float):
         self.qubit_noise_gate = ops.DepolarizingChannel(depol_prob)
         self.readout_noise_gate = ops.BitFlipChannel(bitflip_prob)
 
-    def noisy_moment(self, moment: cirq.Moment, system_qubits: Sequence[cirq.Qid]):
+    def noisy_moment(self, moment: cirq.Moment, system_qubits: Sequence[cirq.Qid]) -> cirq.OP_TREE:
         if validate_all_measurements(moment):
             return [circuits.Moment(self.readout_noise_gate(q) for q in system_qubits), moment]
         return [moment, circuits.Moment(self.qubit_noise_gate(q) for q in system_qubits)]
@@ -178,7 +178,7 @@ def __init__(self, depol_prob: float, bitflip_prob: float, decay_prob: float):
         self.readout_noise_gate = ops.BitFlipChannel(bitflip_prob)
         self.readout_decay_gate = ops.AmplitudeDampingChannel(decay_prob)
 
-    def noisy_moment(self, moment: cirq.Moment, system_qubits: Sequence[cirq.Qid]):
+    def noisy_moment(self, moment: cirq.Moment, system_qubits: Sequence[cirq.Qid]) -> cirq.OP_TREE:
         if validate_all_measurements(moment):
             return [
                 circuits.Moment(self.readout_decay_gate(q) for q in system_qubits),
diff --git a/cirq-core/cirq/contrib/noise_models/noise_models_test.py b/cirq-core/cirq/contrib/noise_models/noise_models_test.py
index 27dc5cae3f1..fe0c9890551 100644
--- a/cirq-core/cirq/contrib/noise_models/noise_models_test.py
+++ b/cirq-core/cirq/contrib/noise_models/noise_models_test.py
@@ -25,6 +25,7 @@ def test_depol_noise() -> None:
     qubits = cirq.LineQubit.range(2)
     moment = cirq.Moment([cirq.X(qubits[0]), cirq.Y(qubits[1])])
     noisy_mom = noise_model.noisy_moment(moment, system_qubits=qubits)
+    assert isinstance(noisy_mom, list)
     assert len(noisy_mom) == 2
     assert noisy_mom[0] == moment
     for g in noisy_mom[1]:
@@ -36,6 +37,7 @@ def test_depol_noise_prepend() -> None:
     qubits = cirq.LineQubit.range(2)
     moment = cirq.Moment([cirq.X(qubits[0]), cirq.Y(qubits[1])])
     noisy_mom = noise_model.noisy_moment(moment, system_qubits=qubits)
+    assert isinstance(noisy_mom, list)
     assert len(noisy_mom) == 2
     assert noisy_mom[1] == moment
     for g in noisy_mom[0]:
@@ -99,6 +101,7 @@ def test_readout_noise_no_prepend() -> None:
     qubits = cirq.LineQubit.range(2)
     moment = cirq.Moment([cirq.measure(*qubits, key="meas")])
     noisy_mom = noise_model.noisy_moment(moment, system_qubits=qubits)
+    assert isinstance(noisy_mom, list)
     assert len(noisy_mom) == 2
     assert noisy_mom[0] == moment
     for g in noisy_mom[1]:
@@ -167,6 +170,7 @@ def test_damped_readout_noise_no_prepend() -> None:
     qubits = cirq.LineQubit.range(2)
     moment = cirq.Moment([cirq.measure(*qubits, key="meas")])
     noisy_mom = noise_model.noisy_moment(moment, system_qubits=qubits)
+    assert isinstance(noisy_mom, list)
     assert len(noisy_mom) == 2
     assert noisy_mom[0] == moment
     for g in noisy_mom[1]:
diff --git a/cirq-core/cirq/contrib/qcircuit/qcircuit_diagram_info.py b/cirq-core/cirq/contrib/qcircuit/qcircuit_diagram_info.py
index d25de46489e..2bb2662d544 100644
--- a/cirq-core/cirq/contrib/qcircuit/qcircuit_diagram_info.py
+++ b/cirq-core/cirq/contrib/qcircuit/qcircuit_diagram_info.py
@@ -17,7 +17,7 @@
 from cirq import ops, protocols
 
 
-def escape_text_for_latex(text):
+def escape_text_for_latex(text: str) -> str:
     escaped = (
         text.replace('\\', r'\textbackslash{}')
         .replace('{', r'\{')
diff --git a/cirq-core/cirq/contrib/qcircuit/qcircuit_diagram_info_test.py b/cirq-core/cirq/contrib/qcircuit/qcircuit_diagram_info_test.py
index bea2e4a2e66..5ee3ea4c811 100644
--- a/cirq-core/cirq/contrib/qcircuit/qcircuit_diagram_info_test.py
+++ b/cirq-core/cirq/contrib/qcircuit/qcircuit_diagram_info_test.py
@@ -18,7 +18,8 @@
 import cirq.contrib.qcircuit as ccq
 
 
-def test_get_qcircuit_diagram_info():
+def test_get_qcircuit_diagram_info() -> None:
+    qubit_map: dict[cirq.LabelEntity, int]
     qubits = cirq.NamedQubit('x'), cirq.NamedQubit('y')
 
     gate = cirq.SwapPowGate(exponent=0.5)
diff --git a/cirq-core/cirq/contrib/qcircuit/qcircuit_pdf.py b/cirq-core/cirq/contrib/qcircuit/qcircuit_pdf.py
index 12044b83288..74f1b679953 100644
--- a/cirq-core/cirq/contrib/qcircuit/qcircuit_pdf.py
+++ b/cirq-core/cirq/contrib/qcircuit/qcircuit_pdf.py
@@ -33,7 +33,7 @@ def circuit_to_pdf_using_qcircuit_via_tex(
     qcircuit_kwargs=None,
     clean_ext=('dvi', 'ps'),
     documentclass='article',
-):
+) -> None:
     """Compiles the QCircuit-based latex diagram of the given circuit.
 
     Args:
diff --git a/cirq-core/cirq/contrib/quantum_volume/quantum_volume_test.py b/cirq-core/cirq/contrib/quantum_volume/quantum_volume_test.py
index 8aa16419167..331164bb894 100644
--- a/cirq-core/cirq/contrib/quantum_volume/quantum_volume_test.py
+++ b/cirq-core/cirq/contrib/quantum_volume/quantum_volume_test.py
@@ -18,7 +18,7 @@ class FakeDevice(cirq.Device):
     qubits = cirq.GridQubit.rect(5, 5)
 
 
-def test_generate_model_circuit():
+def test_generate_model_circuit() -> None:
     """Test that a model circuit is randomly generated."""
     model_circuit = cirq.contrib.quantum_volume.generate_model_circuit(
         3, 3, random_state=np.random.RandomState(1)
@@ -29,7 +29,7 @@ def test_generate_model_circuit():
     assert list(model_circuit.findall_operations_with_gate_type(cirq.MeasurementGate)) == []
 
 
-def test_generate_model_circuit_without_seed():
+def test_generate_model_circuit_without_seed() -> None:
     """Test that a model circuit is randomly generated without a seed."""
     model_circuit = cirq.contrib.quantum_volume.generate_model_circuit(3, 3)
 
@@ -38,7 +38,7 @@ def test_generate_model_circuit_without_seed():
     assert list(model_circuit.findall_operations_with_gate_type(cirq.MeasurementGate)) == []
 
 
-def test_generate_model_circuit_seed():
+def test_generate_model_circuit_seed() -> None:
     """Test that a model circuit is determined by its seed ."""
     model_circuit_1 = cirq.contrib.quantum_volume.generate_model_circuit(
         3, 3, random_state=np.random.RandomState(1)
@@ -54,7 +54,7 @@ def test_generate_model_circuit_seed():
     assert model_circuit_2 != model_circuit_3
 
 
-def test_compute_heavy_set():
+def test_compute_heavy_set() -> None:
     """Test that the heavy set can be computed from a given circuit."""
     a, b, c = cirq.LineQubit.range(3)
     model_circuit = cirq.Circuit(
@@ -69,7 +69,7 @@ def test_compute_heavy_set():
     assert cirq.contrib.quantum_volume.compute_heavy_set(model_circuit) == [5, 7]
 
 
-def test_sample_heavy_set():
+def test_sample_heavy_set() -> None:
     """Test that we correctly sample a circuit's heavy set"""
 
     sampler = Mock(spec=cirq.Simulator)
@@ -89,7 +89,7 @@ def test_sample_heavy_set():
     assert probability == 0.75
 
 
-def test_sample_heavy_set_with_parity():
+def test_sample_heavy_set_with_parity() -> None:
     """Test that we correctly sample a circuit's heavy set with a parity map"""
 
     sampler = Mock(spec=cirq.Simulator)
@@ -122,7 +122,7 @@ def test_sample_heavy_set_with_parity():
     assert probability == 0.5
 
 
-def test_compile_circuit_router():
+def test_compile_circuit_router() -> None:
     """Tests that the given router is used."""
     router_mock = MagicMock()
     cirq.contrib.quantum_volume.compile_circuit(
@@ -134,7 +134,7 @@ def test_compile_circuit_router():
     router_mock.assert_called()
 
 
-def test_compile_circuit():
+def test_compile_circuit() -> None:
     """Tests that we are able to compile a model circuit."""
     compiler_mock = MagicMock(side_effect=lambda circuit: circuit)
     a, b, c = cirq.LineQubit.range(3)
@@ -154,7 +154,7 @@ def test_compile_circuit():
     compiler_mock.assert_called_with(compilation_result.circuit)
 
 
-def test_compile_circuit_replaces_swaps():
+def test_compile_circuit_replaces_swaps() -> None:
     """Tests that the compiler never sees the SwapPermutationGates from the
     router."""
     compiler_mock = MagicMock(side_effect=lambda circuit: circuit)
@@ -195,7 +195,7 @@ def test_compile_circuit_replaces_swaps():
     )
 
 
-def test_compile_circuit_with_readout_correction():
+def test_compile_circuit_with_readout_correction() -> None:
     """Tests that we are able to compile a model circuit with readout error
     correction."""
     compiler_mock = MagicMock(side_effect=lambda circuit: circuit)
@@ -222,9 +222,10 @@ def test_compile_circuit_with_readout_correction():
     )
 
 
-def test_compile_circuit_multiple_routing_attempts():
+def test_compile_circuit_multiple_routing_attempts() -> None:
     """Tests that we make multiple attempts at routing and keep the best one."""
     qubits = cirq.LineQubit.range(3)
+    initial_mapping: dict[cirq.Qid, cirq.Qid]
     initial_mapping = dict(zip(qubits, qubits))
     more_operations = cirq.Circuit([cirq.X.on_each(qubits), cirq.Y.on_each(qubits)])
     more_qubits = cirq.Circuit([cirq.X.on_each(cirq.LineQubit.range(4))])
@@ -252,7 +253,7 @@ def test_compile_circuit_multiple_routing_attempts():
     compiler_mock.assert_called_with(well_routed)
 
 
-def test_compile_circuit_no_routing_attempts():
+def test_compile_circuit_no_routing_attempts() -> None:
     """Tests that setting no routing attempts throws an error."""
     a, b, c = cirq.LineQubit.range(3)
     model_circuit = cirq.Circuit([cirq.Moment([cirq.X(a), cirq.Y(b), cirq.Z(c)])])
@@ -266,7 +267,7 @@ def test_compile_circuit_no_routing_attempts():
     assert e.match('Unable to get routing for circuit')
 
 
-def test_calculate_quantum_volume_result():
+def test_calculate_quantum_volume_result() -> None:
     """Test that running the main loop returns the desired result"""
     results = cirq.contrib.quantum_volume.calculate_quantum_volume(
         num_qubits=3,
@@ -287,7 +288,7 @@ def test_calculate_quantum_volume_result():
     cirq.to_json(results, buffer)
 
 
-def test_calculate_quantum_volume_result_with_device_graph():
+def test_calculate_quantum_volume_result_with_device_graph() -> None:
     """Test that running the main loop routes the circuit onto the given device
     graph"""
     device_qubits = [cirq.GridQubit(i, j) for i in range(2) for j in range(3)]
@@ -308,7 +309,7 @@ def test_calculate_quantum_volume_result_with_device_graph():
     )
 
 
-def test_calculate_quantum_volume_loop():
+def test_calculate_quantum_volume_loop() -> None:
     """Test that calculate_quantum_volume is able to run without erring."""
     # Keep test from taking a long time by lowering circuits and routing
     # attempts.
@@ -323,7 +324,7 @@ def test_calculate_quantum_volume_loop():
     )
 
 
-def test_calculate_quantum_volume_loop_with_readout_correction():
+def test_calculate_quantum_volume_loop_with_readout_correction() -> None:
     """Test that calculate_quantum_volume is able to run without erring with
     readout error correction."""
     # Keep test from taking a long time by lowering circuits and routing
diff --git a/cirq-core/cirq/contrib/quimb/density_matrix.py b/cirq-core/cirq/contrib/quimb/density_matrix.py
index bfa6335135f..0abc85fb0e0 100644
--- a/cirq-core/cirq/contrib/quimb/density_matrix.py
+++ b/cirq-core/cirq/contrib/quimb/density_matrix.py
@@ -197,7 +197,7 @@ def _positions(_mi, _these_qubits):
 
 
 def tensor_density_matrix(
-    circuit: cirq.Circuit, qubits: list[cirq.Qid] | None = None
+    circuit: cirq.Circuit, qubits: Sequence[cirq.Qid] | None = None
 ) -> np.ndarray:
     """Given a circuit with mixtures or channels, contract a tensor network
     representing the resultant density matrix.
diff --git a/cirq-core/cirq/contrib/quimb/density_matrix_test.py b/cirq-core/cirq/contrib/quimb/density_matrix_test.py
index 3e18bc9f78f..26e5282870a 100644
--- a/cirq-core/cirq/contrib/quimb/density_matrix_test.py
+++ b/cirq-core/cirq/contrib/quimb/density_matrix_test.py
@@ -8,7 +8,7 @@
 import cirq.contrib.quimb as ccq
 
 
-def test_tensor_density_matrix_1():
+def test_tensor_density_matrix_1() -> None:
     q = cirq.LineQubit.range(2)
     c = cirq.Circuit(cirq.YPowGate(exponent=0.25).on(q[0]))
 
@@ -17,7 +17,7 @@ def test_tensor_density_matrix_1():
     np.testing.assert_allclose(rho1, rho2, atol=1e-15)
 
 
-def test_tensor_density_matrix_optional_qubits():
+def test_tensor_density_matrix_optional_qubits() -> None:
     q = cirq.LineQubit.range(2)
     c = cirq.Circuit(cirq.YPowGate(exponent=0.25).on(q[0]))
 
@@ -26,7 +26,7 @@ def test_tensor_density_matrix_optional_qubits():
     np.testing.assert_allclose(rho1, rho2, atol=1e-15)
 
 
-def test_tensor_density_matrix_noise_1():
+def test_tensor_density_matrix_noise_1() -> None:
     q = cirq.LineQubit.range(2)
     c = cirq.Circuit(
         cirq.YPowGate(exponent=0.25).on(q[0]),
@@ -39,7 +39,7 @@ def test_tensor_density_matrix_noise_1():
     np.testing.assert_allclose(rho1, rho2, atol=1e-15)
 
 
-def test_tensor_density_matrix_2():
+def test_tensor_density_matrix_2() -> None:
     q = cirq.LineQubit.range(2)
     rs = np.random.RandomState(52)
     for _ in range(10):
@@ -50,7 +50,7 @@ def test_tensor_density_matrix_2():
         np.testing.assert_allclose(rho1, rho2, atol=1e-8)
 
 
-def test_tensor_density_matrix_3():
+def test_tensor_density_matrix_3() -> None:
     qubits = cirq.LineQubit.range(10)
     circuit = cirq.testing.random_circuit(qubits=qubits, n_moments=10, op_density=0.8)
     rho1 = cirq.final_density_matrix(circuit, dtype=np.complex128)
@@ -58,7 +58,7 @@ def test_tensor_density_matrix_3():
     np.testing.assert_allclose(rho1, rho2, atol=1e-8)
 
 
-def test_tensor_density_matrix_4():
+def test_tensor_density_matrix_4() -> None:
     qubits = cirq.LineQubit.range(4)
     circuit = cirq.testing.random_circuit(qubits=qubits, n_moments=100, op_density=0.8)
     circuit = cirq.drop_empty_moments(circuit)
@@ -69,7 +69,7 @@ def test_tensor_density_matrix_4():
     np.testing.assert_allclose(rho1, rho2, atol=1e-8)
 
 
-def test_tensor_density_matrix_gridqubit():
+def test_tensor_density_matrix_gridqubit() -> None:
     qubits = cirq.GridQubit.rect(2, 2)
     circuit = cirq.testing.random_circuit(qubits=qubits, n_moments=10, op_density=0.8)
     circuit = cirq.drop_empty_moments(circuit)
diff --git a/cirq-core/cirq/devices/noise_model_test.py b/cirq-core/cirq/devices/noise_model_test.py
index f595e3b5150..2c5ba13422f 100644
--- a/cirq-core/cirq/devices/noise_model_test.py
+++ b/cirq-core/cirq/devices/noise_model_test.py
@@ -25,13 +25,15 @@
 from cirq.testing import assert_equivalent_op_tree
 
 
-def assert_equivalent_op_tree_sequence(x: Sequence[cirq.OP_TREE], y: Sequence[cirq.OP_TREE]):
+def assert_equivalent_op_tree_sequence(
+    x: Sequence[cirq.OP_TREE], y: Sequence[cirq.OP_TREE]
+) -> None:
     assert len(x) == len(y)
     for a, b in zip(x, y):
         assert_equivalent_op_tree(a, b)
 
 
-def test_requires_one_override():
+def test_requires_one_override() -> None:
     class C(cirq.NoiseModel):
         pass
 
@@ -39,7 +41,7 @@ class C(cirq.NoiseModel):
         _ = C()
 
 
-def test_infers_other_methods():
+def test_infers_other_methods() -> None:
     q = cirq.LineQubit(0)
 
     class NoiseModelWithNoisyMomentListMethod(cirq.NoiseModel):
@@ -93,7 +95,7 @@ def noisy_operation(self, operation: cirq.Operation):
     )
 
 
-def test_no_noise():
+def test_no_noise() -> None:
     q = cirq.LineQubit(0)
     m = cirq.Moment([cirq.X(q)])
     assert cirq.NO_NOISE.noisy_operation(cirq.X(q)) == cirq.X(q)
@@ -104,7 +106,7 @@ def test_no_noise():
     cirq.testing.assert_equivalent_repr(cirq.NO_NOISE)
 
 
-def test_constant_qubit_noise():
+def test_constant_qubit_noise() -> None:
     a, b, c = cirq.LineQubit.range(3)
     damp = cirq.amplitude_damp(0.5)
     damp_all = cirq.ConstantQubitNoiseModel(damp)
@@ -126,7 +128,7 @@ def test_constant_qubit_noise():
         _ = cirq.ConstantQubitNoiseModel(cirq.CNOT**0.01)
 
 
-def test_constant_qubit_noise_prepend():
+def test_constant_qubit_noise_prepend() -> None:
     a, b, c = cirq.LineQubit.range(3)
     damp = cirq.amplitude_damp(0.5)
     damp_all = cirq.ConstantQubitNoiseModel(damp, prepend=True)
@@ -145,7 +147,7 @@ def test_constant_qubit_noise_prepend():
     cirq.testing.assert_equivalent_repr(damp_all)
 
 
-def test_noise_composition():
+def test_noise_composition() -> None:
     # Verify that noise models can be composed without regard to ordering, as
     # long as the noise operators commute with one another.
     a, b, c = cirq.LineQubit.range(3)
@@ -174,11 +176,11 @@ def test_noise_composition():
     assert_equivalent_op_tree(actual_zs, expected_circuit)
 
 
-def test_constant_qubit_noise_repr():
+def test_constant_qubit_noise_repr() -> None:
     cirq.testing.assert_equivalent_repr(cirq.ConstantQubitNoiseModel(cirq.X**0.01))
 
 
-def test_wrap():
+def test_wrap() -> None:
     class Forget(cirq.NoiseModel):
         def noisy_operation(self, operation):
             raise NotImplementedError()
@@ -195,13 +197,13 @@ def noisy_operation(self, operation):
     assert cirq.NoiseModel.from_noise_model_like(forget) is forget
 
     with pytest.raises(TypeError, match='Expected a NOISE_MODEL_LIKE'):
-        _ = cirq.NoiseModel.from_noise_model_like('test')
+        _ = cirq.NoiseModel.from_noise_model_like('test')  # type: ignore[arg-type]
 
     with pytest.raises(ValueError, match='Multi-qubit gate'):
         _ = cirq.NoiseModel.from_noise_model_like(cirq.CZ**0.01)
 
 
-def test_gate_substitution_noise_model():
+def test_gate_substitution_noise_model() -> None:
     def _overrotation(op):
         if isinstance(op.gate, cirq.XPowGate):
             return cirq.XPowGate(exponent=op.gate.exponent + 0.1).on(*op.qubits)
@@ -217,14 +219,14 @@ def _overrotation(op):
     np.testing.assert_allclose(rho1, rho2)
 
 
-def test_moment_is_measurements():
+def test_moment_is_measurements() -> None:
     q = cirq.LineQubit.range(2)
     circ = cirq.Circuit([cirq.X(q[0]), cirq.X(q[1]), cirq.measure(*q, key='z')])
     assert not validate_all_measurements(circ[0])
     assert validate_all_measurements(circ[1])
 
 
-def test_moment_is_measurements_mixed1():
+def test_moment_is_measurements_mixed1() -> None:
     q = cirq.LineQubit.range(2)
     circ = cirq.Circuit([cirq.X(q[0]), cirq.X(q[1]), cirq.measure(q[0], key='z'), cirq.Z(q[1])])
     assert not validate_all_measurements(circ[0])
@@ -233,7 +235,7 @@ def test_moment_is_measurements_mixed1():
     assert e.match(".*must be homogeneous: all measurements.*")
 
 
-def test_moment_is_measurements_mixed2():
+def test_moment_is_measurements_mixed2() -> None:
     q = cirq.LineQubit.range(2)
     circ = cirq.Circuit([cirq.X(q[0]), cirq.X(q[1]), cirq.Z(q[0]), cirq.measure(q[1], key='z')])
     assert not validate_all_measurements(circ[0])