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

cirq/circuits/moment_test.py

@@ -22,7 +22,7 @@ import cirq
 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 @@ aa │
     )
 
 
-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 @@ def test_op_has_no_kraus():
     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)

cirq/circuits/optimization_pass.py

@@ -126,7 +126,7 @@ class PointOptimizer:
             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.

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 @@ class TextDiagramDrawer:
         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 @@ class TextDiagramDrawer:
     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 @@ class TextDiagramDrawer:
 
     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 @@ class TextDiagramDrawer:
 
         return block_diagram.render()
 
-    def copy(self):
+    def copy(self) -> Self:
         return self.__class__(
             entries=self.entries,
             vertical_lines=self.vertical_lines,

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')

cirq/contrib/acquaintance/bipartite_test.py

@@ -270,7 +270,7 @@ circuit_diagrams = {
 @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))

cirq/contrib/acquaintance/devices_test.py

@@ -20,7 +20,7 @@ import cirq
 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]

cirq/contrib/acquaintance/executor_test.py

@@ -16,7 +16,7 @@ from __future__ import annotations
 
 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 @@ class ExampleGate(cirq.Gate):
         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)

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: