cirq-core 1.6.0.dev20250702182429__py3-none-any.whl → 1.6.0.dev20250702211226__py3-none-any.whl

cirq/contrib/custom_simulators/custom_state_simulator_test.py

@@ -30,7 +30,9 @@ class ComputationalBasisState(cirq.qis.QuantumStateRepresentation):
     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 @@ class ComputationalBasisSimState(cirq.SimulationState[ComputationalBasisState]):
             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 @@ class ComputationalBasisProductState(cirq.qis.QuantumStateRepresentation):
     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:

cirq/contrib/graph_device/graph_device.py

@@ -16,7 +16,7 @@ from __future__ import annotations
 
 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 @@ class UndirectedGraphDevice(devices.Device):
         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 @@ class UndirectedGraphDevice(devices.Device):
             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 @@ class UndirectedGraphDevice(devices.Device):
             ):
                 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):

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 as ccgd
 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 test_graph_device():
 
     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 test_graph_device():
     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 test_graph_device():
     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 test_graph_device():
         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(

cirq/contrib/graph_device/hypergraph.py

@@ -71,7 +71,7 @@ class UndirectedHypergraph:
                 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 @@ class UndirectedHypergraph:
             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)
 

cirq/contrib/graph_device/hypergraph_test.py

@@ -21,7 +21,7 @@ import pytest
 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')]

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)

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 "

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

cirq/contrib/noise_models/noise_models.py

@@ -42,7 +42,7 @@ class DepolarizingNoiseModel(devices.NoiseModel):
         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 @@ class ReadoutNoiseModel(devices.NoiseModel):
         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 @@ class DampedReadoutNoiseModel(devices.NoiseModel):
         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 @@ class DepolarizingWithReadoutNoiseModel(devices.NoiseModel):
         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 @@ class DepolarizingWithDampedReadoutNoiseModel(devices.NoiseModel):
         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),

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]:

cirq/contrib/qcircuit/qcircuit_diagram_info.py

@@ -17,7 +17,7 @@ from __future__ import annotations
 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'\{')

cirq/contrib/qcircuit/qcircuit_diagram_info_test.py

@@ -18,7 +18,8 @@ import cirq
 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)

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:

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

cirq/contrib/quimb/density_matrix.py

@@ -197,7 +197,7 @@ def circuit_to_density_matrix_tensors(
 
 
 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.

cirq/contrib/quimb/density_matrix_test.py

@@ -8,7 +8,7 @@ import cirq
 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)