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

cirq/protocols/measurement_key_protocol.py

@@ -17,7 +17,7 @@
 from __future__ import annotations
 
 from types import NotImplementedType
-from typing import Any, Mapping, Protocol, TYPE_CHECKING
+from typing import Any, Mapping, overload, Protocol, TYPE_CHECKING, TypeVar
 
 from cirq import value
 from cirq._doc import doc_private
@@ -25,6 +25,9 @@ from cirq._doc import doc_private
 if TYPE_CHECKING:
     import cirq
 
+T = TypeVar('T')
+TDefault = TypeVar('TDefault')
+
 # This is a special indicator value used by the inverse method to determine
 # whether or not the caller provided a 'default' argument.
 RaiseTypeErrorIfNotProvided: Any = ([],)
@@ -104,7 +107,17 @@ class SupportsMeasurementKey(Protocol):
         """
 
 
-def measurement_key_obj(val: Any, default: Any = RaiseTypeErrorIfNotProvided):
+@overload
+def measurement_key_obj(val: Any) -> cirq.MeasurementKey:
+    pass
+
+
+@overload
+def measurement_key_obj(val: Any, default: TDefault) -> cirq.MeasurementKey | TDefault:
+    pass
+
+
+def measurement_key_obj(val, default=RaiseTypeErrorIfNotProvided):
     """Get the single measurement key object for the given value.
 
     Args:
@@ -138,7 +151,17 @@ def measurement_key_obj(val: Any, default: Any = RaiseTypeErrorIfNotProvided):
     raise TypeError(f"Object of type '{type(val)}' had no measurement keys.")
 
 
-def measurement_key_name(val: Any, default: Any = RaiseTypeErrorIfNotProvided):
+@overload
+def measurement_key_name(val: Any) -> str:
+    pass
+
+
+@overload
+def measurement_key_name(val: Any, default: TDefault) -> str | TDefault:
+    pass
+
+
+def measurement_key_name(val, default=RaiseTypeErrorIfNotProvided):
     """Get the single measurement key for the given value.
 
     Args:
@@ -278,7 +301,7 @@ def is_measurement(val: Any) -> bool:
     return keys is not NotImplemented and bool(keys)
 
 
-def with_measurement_key_mapping(val: Any, key_map: Mapping[str, str]):
+def with_measurement_key_mapping(val: T, key_map: Mapping[str, str]) -> T:
     """Remaps the target's measurement keys according to the provided key_map.
 
     This method can be used to reassign measurement keys at runtime, or to
@@ -288,7 +311,7 @@ def with_measurement_key_mapping(val: Any, key_map: Mapping[str, str]):
     return NotImplemented if getter is None else getter(key_map)
 
 
-def with_key_path(val: Any, path: tuple[str, ...]):
+def with_key_path(val: T, path: tuple[str, ...]) -> T:
     """Adds the path to the target's measurement keys.
 
     The path usually refers to an identifier or a list of identifiers from a subcircuit that
@@ -299,7 +322,7 @@ def with_key_path(val: Any, path: tuple[str, ...]):
     return NotImplemented if getter is None else getter(path)
 
 
-def with_key_path_prefix(val: Any, prefix: tuple[str, ...]):
+def with_key_path_prefix(val: T, prefix: tuple[str, ...]) -> T:
     """Prefixes the path to the target's measurement keys.
 
     The path usually refers to an identifier or a list of identifiers from a subcircuit that
@@ -315,8 +338,8 @@ def with_key_path_prefix(val: Any, prefix: tuple[str, ...]):
 
 
 def with_rescoped_keys(
-    val: Any, path: tuple[str, ...], bindable_keys: frozenset[cirq.MeasurementKey] | None = None
-):
+    val: T, path: tuple[str, ...], bindable_keys: frozenset[cirq.MeasurementKey] | None = None
+) -> T:
     """Rescopes any measurement and control keys to the provided path, given the existing keys.
 
     The path usually refers to an identifier or a list of identifiers from a subcircuit that

cirq/protocols/mixture_protocol.py

@@ -148,7 +148,7 @@ def has_mixture(val: Any, *, allow_decompose: bool = True) -> bool:
     return mixture(val, None) is not None
 
 
-def validate_mixture(supports_mixture: SupportsMixture):
+def validate_mixture(supports_mixture: SupportsMixture) -> None:
     """Validates that the mixture's tuple are valid probabilities."""
     mixture_tuple = mixture(supports_mixture, None)
     if mixture_tuple is None:

cirq/protocols/mixture_protocol_test.py

@@ -93,7 +93,7 @@ class ReturnsMixtureOfReturnsUnitary:
         (ReturnsMixtureOfReturnsUnitary(), ((0.4, np.eye(2)), (0.6, np.eye(2)))),
     ),
 )
-def test_objects_with_mixture(val, mixture):
+def test_objects_with_mixture(val, mixture) -> None:
     expected_keys, expected_values = zip(*mixture)
     keys, values = zip(*cirq.mixture(val))
     np.testing.assert_almost_equal(keys, expected_keys)
@@ -107,7 +107,7 @@ def test_objects_with_mixture(val, mixture):
 @pytest.mark.parametrize(
     'val', (NoMethod(), ReturnsNotImplemented(), ReturnsNotImplementedUnitary())
 )
-def test_objects_with_no_mixture(val):
+def test_objects_with_no_mixture(val) -> None:
     with pytest.raises(TypeError, match="mixture"):
         _ = cirq.mixture(val)
     assert cirq.mixture(val, None) is None
@@ -116,7 +116,7 @@ def test_objects_with_no_mixture(val):
     assert cirq.mixture(val, default) == default
 
 
-def test_has_mixture():
+def test_has_mixture() -> None:
     assert cirq.has_mixture(ReturnsValidTuple())
     assert not cirq.has_mixture(ReturnsNotImplemented())
     assert cirq.has_mixture(ReturnsMixtureButNoHasMixture())
@@ -124,7 +124,7 @@ def test_has_mixture():
     assert not cirq.has_mixture(ReturnsNotImplementedUnitary())
 
 
-def test_valid_mixture():
+def test_valid_mixture() -> None:
     cirq.validate_mixture(ReturnsValidTuple())
 
 
@@ -136,11 +136,11 @@ def test_valid_mixture():
         (ReturnsGreaterThanUnityProbability(), 'greater than 1'),
     ),
 )
-def test_invalid_mixture(val, message):
+def test_invalid_mixture(val, message) -> None:
     with pytest.raises(ValueError, match=message):
         cirq.validate_mixture(val)
 
 
-def test_missing_mixture():
+def test_missing_mixture() -> None:
     with pytest.raises(TypeError, match='_mixture_'):
-        cirq.validate_mixture(NoMethod)
+        cirq.validate_mixture(NoMethod)  # type: ignore[arg-type]

cirq/protocols/mul_protocol_test.py

@@ -52,7 +52,7 @@ class MulSevenRMulEight:
         return 8
 
 
-def test_equivalent_to_builtin_mul():
+def test_equivalent_to_builtin_mul() -> None:
     test_vals = [
         0,
         1,
@@ -76,14 +76,14 @@ def test_equivalent_to_builtin_mul():
             c = cirq.mul(a, b, default=None)
             if c is None:
                 with pytest.raises(TypeError):
-                    _ = a * b
+                    _ = a * b  # type: ignore[operator]
                 with pytest.raises(TypeError):
                     _ = cirq.mul(a, b)
             else:
-                assert c == a * b
+                assert c == a * b  # type: ignore[operator]
 
 
-def test_symbol_special_case():
+def test_symbol_special_case() -> None:
     x = sympy.Symbol('x')
     assert cirq.mul(x, 1.0) is x
     assert cirq.mul(1.0, x) is x

cirq/protocols/phase_protocol.py

@@ -14,7 +14,7 @@
 
 from __future__ import annotations
 
-from typing import Any, Protocol, TypeVar
+from typing import Any, overload, Protocol, TypeVar
 
 # This is a special value to indicate that a type error should be returned.
 # This is used within phase_by to raise an error if no underlying
@@ -24,6 +24,7 @@ from cirq._doc import doc_private
 RaiseTypeErrorIfNotProvided: Any = ([],)
 
 TDefault = TypeVar('TDefault')
+T = TypeVar('T')
 
 
 class SupportsPhase(Protocol):
@@ -47,9 +48,17 @@ class SupportsPhase(Protocol):
         """
 
 
-def phase_by(
-    val: Any, phase_turns: float, qubit_index: int, default: TDefault = RaiseTypeErrorIfNotProvided
-):
+@overload
+def phase_by(val: T, phase_turns: float, qubit_index: int) -> T:
+    pass
+
+
+@overload
+def phase_by(val: T, phase_turns: float, qubit_index: int, default: TDefault) -> T | TDefault:
+    pass
+
+
+def phase_by(val, phase_turns, qubit_index, default=RaiseTypeErrorIfNotProvided):
     """Returns a phased version of the effect.
 
     For example, an X gate phased by 90 degrees would be a Y gate.

cirq/protocols/pow_protocol_test.py

@@ -34,7 +34,7 @@ class ReturnsExponent:
 
 
 @pytest.mark.parametrize('val', (NoMethod(), 'text', object(), ReturnsNotImplemented()))
-def test_powerless(val):
+def test_powerless(val) -> None:
     assert cirq.pow(val, 5, None) is None
     assert cirq.pow(val, 2, NotImplemented) is NotImplemented
 
@@ -42,13 +42,13 @@ def test_powerless(val):
     assert cirq.pow(val, 1, None) is None
 
 
-def test_pow_error():
+def test_pow_error() -> None:
     with pytest.raises(TypeError, match="returned NotImplemented"):
-        _ = cirq.pow(ReturnsNotImplemented(), 3)
+        _ = cirq.pow(ReturnsNotImplemented(), 3)  # type: ignore[call-overload]
     with pytest.raises(TypeError, match="no __pow__ method"):
-        _ = cirq.pow(NoMethod(), 3)
+        _ = cirq.pow(NoMethod(), 3)  # type: ignore[call-overload]
 
 
 @pytest.mark.parametrize('val,exponent,out', ((ReturnsExponent(), 2, 2), (1, 2, 1), (2, 3, 8)))
-def test_pow_with_result(val, exponent, out):
+def test_pow_with_result(val, exponent, out) -> None:
     assert cirq.pow(val, exponent) == cirq.pow(val, exponent, default=None) == val**exponent == out

cirq/protocols/resolve_parameters.py

@@ -196,6 +196,6 @@ def resolve_parameters(
         return val
 
 
-def resolve_parameters_once(val: Any, param_resolver: cirq.ParamResolverOrSimilarType):
+def resolve_parameters_once(val: T, param_resolver: cirq.ParamResolverOrSimilarType) -> T:
     """Performs a single parameter resolution step using the param resolver."""
     return resolve_parameters(val, param_resolver, False)

cirq/protocols/unitary_protocol_test.py

@@ -56,7 +56,7 @@ class ReturnsNotImplemented(cirq.Gate):
     def _unitary_(self):
         return NotImplemented
 
-    def num_qubits(self):
+    def num_qubits(self) -> int:
         return 1
 
 
@@ -64,7 +64,7 @@ class ReturnsMatrix(cirq.Gate):
     def _unitary_(self) -> np.ndarray:
         return m1
 
-    def num_qubits(self):
+    def num_qubits(self) -> int:
         return 1  # pragma: no cover
 
 
@@ -80,7 +80,7 @@ class FullyImplemented(cirq.Gate):
             return None
         return m1
 
-    def num_qubits(self):
+    def num_qubits(self) -> int:
         return 1
 
 
@@ -88,7 +88,7 @@ class DecomposableGate(cirq.Gate):
     def __init__(self, unitary_value):
         self.unitary_value = unitary_value
 
-    def num_qubits(self):
+    def num_qubits(self) -> int:
         return 1
 
     def _decompose_(self, qubits):
@@ -154,7 +154,7 @@ class OtherComposite:
         yield cirq.X(cirq.LineQubit(3))
 
 
-def test_unitary():
+def test_unitary() -> None:
     with pytest.raises(TypeError, match='unitary effect'):
         _ = cirq.unitary(NoMethod())
     with pytest.raises(TypeError, match='unitary effect'):
@@ -186,7 +186,7 @@ def test_unitary():
     assert cirq.unitary(FullyImplemented(False), default=None) is None
 
 
-def test_has_unitary():
+def test_has_unitary() -> None:
     assert not cirq.has_unitary(NoMethod())
     assert not cirq.has_unitary(ReturnsNotImplemented())
     assert cirq.has_unitary(ReturnsMatrix())
@@ -215,7 +215,7 @@ def _test_gate_that_allocates_qubits(gate):
 @pytest.mark.parametrize('ancilla_bitsize', [1, 4])
 def test_decompose_gate_that_allocates_clean_qubits(
     theta: float, phase_state: int, target_bitsize: int, ancilla_bitsize: int
-):
+) -> None:
     gate = testing.PhaseUsingCleanAncilla(theta, phase_state, target_bitsize, ancilla_bitsize)
     _test_gate_that_allocates_qubits(gate)
 
@@ -225,26 +225,38 @@ def test_decompose_gate_that_allocates_clean_qubits(
 @pytest.mark.parametrize('ancilla_bitsize', [1, 4])
 def test_decompose_gate_that_allocates_dirty_qubits(
     phase_state: int, target_bitsize: int, ancilla_bitsize: int
-):
+) -> None:
     gate = testing.PhaseUsingDirtyAncilla(phase_state, target_bitsize, ancilla_bitsize)
     _test_gate_that_allocates_qubits(gate)
 
 
-def test_decompose_and_get_unitary():
+def test_decompose_and_get_unitary() -> None:
     from cirq.protocols.unitary_protocol import _strat_unitary_from_decompose
 
-    np.testing.assert_allclose(_strat_unitary_from_decompose(DecomposableOperation((a,), True)), m1)
     np.testing.assert_allclose(
-        _strat_unitary_from_decompose(DecomposableOperation((a, b), True)), m2
+        _strat_unitary_from_decompose(DecomposableOperation((a,), True)), m1  # type: ignore[arg-type]
+    )
+    np.testing.assert_allclose(
+        _strat_unitary_from_decompose(DecomposableOperation((a, b), True)), m2  # type: ignore[arg-type]
+    )
+    np.testing.assert_allclose(
+        _strat_unitary_from_decompose(DecomposableOrder((a, b, c))), m3  # type: ignore[arg-type]
+    )
+    np.testing.assert_allclose(
+        _strat_unitary_from_decompose(ExampleOperation((a,))), np.eye(2)  # type: ignore[arg-type]
+    )
+    np.testing.assert_allclose(
+        _strat_unitary_from_decompose(ExampleOperation((a, b))), np.eye(4)  # type: ignore[arg-type]
+    )
+    np.testing.assert_allclose(
+        _strat_unitary_from_decompose(ExampleComposite()), np.eye(1)  # type: ignore[arg-type]
+    )
+    np.testing.assert_allclose(
+        _strat_unitary_from_decompose(OtherComposite()), m2  # type: ignore[arg-type]
     )
-    np.testing.assert_allclose(_strat_unitary_from_decompose(DecomposableOrder((a, b, c))), m3)
-    np.testing.assert_allclose(_strat_unitary_from_decompose(ExampleOperation((a,))), np.eye(2))
-    np.testing.assert_allclose(_strat_unitary_from_decompose(ExampleOperation((a, b))), np.eye(4))
-    np.testing.assert_allclose(_strat_unitary_from_decompose(ExampleComposite()), np.eye(1))
-    np.testing.assert_allclose(_strat_unitary_from_decompose(OtherComposite()), m2)
 
 
-def test_decomposed_has_unitary():
+def test_decomposed_has_unitary() -> None:
     # Gates
     assert cirq.has_unitary(DecomposableGate(True))
     assert not cirq.has_unitary(DecomposableGate(False))
@@ -263,7 +275,7 @@ def test_decomposed_has_unitary():
     assert cirq.has_unitary(OtherComposite())
 
 
-def test_decomposed_unitary():
+def test_decomposed_unitary() -> None:
     # Gates
     np.testing.assert_allclose(cirq.unitary(DecomposableGate(True)), m1)
 
@@ -283,7 +295,7 @@ def test_decomposed_unitary():
     np.testing.assert_allclose(cirq.unitary(OtherComposite()), m2)
 
 
-def test_unitary_from_apply_unitary():
+def test_unitary_from_apply_unitary() -> None:
     class ApplyGate(cirq.Gate):
         def num_qubits(self):
             return 1

cirq/qis/clifford_tableau.py

@@ -38,7 +38,7 @@ class StabilizerState(
     """
 
     @abc.abstractmethod
-    def apply_x(self, axis: int, exponent: float = 1, global_shift: float = 0):
+    def apply_x(self, axis: int, exponent: float = 1, global_shift: float = 0) -> None:
         """Apply an X operation to the state.
 
         Args:
@@ -51,7 +51,7 @@ class StabilizerState(
         """
 
     @abc.abstractmethod
-    def apply_y(self, axis: int, exponent: float = 1, global_shift: float = 0):
+    def apply_y(self, axis: int, exponent: float = 1, global_shift: float = 0) -> None:
         """Apply an Y operation to the state.
 
         Args:
@@ -64,7 +64,7 @@ class StabilizerState(
         """
 
     @abc.abstractmethod
-    def apply_z(self, axis: int, exponent: float = 1, global_shift: float = 0):
+    def apply_z(self, axis: int, exponent: float = 1, global_shift: float = 0) -> None:
         """Apply a Z operation to the state.
 
         Args:
@@ -77,7 +77,7 @@ class StabilizerState(
         """
 
     @abc.abstractmethod
-    def apply_h(self, axis: int, exponent: float = 1, global_shift: float = 0):
+    def apply_h(self, axis: int, exponent: float = 1, global_shift: float = 0) -> None:
         """Apply an H operation to the state.
 
         Args:
@@ -92,7 +92,7 @@ class StabilizerState(
     @abc.abstractmethod
     def apply_cz(
         self, control_axis: int, target_axis: int, exponent: float = 1, global_shift: float = 0
-    ):
+    ) -> None:
         """Apply a CZ operation to the state.
 
         Args:
@@ -108,7 +108,7 @@ class StabilizerState(
     @abc.abstractmethod
     def apply_cx(
         self, control_axis: int, target_axis: int, exponent: float = 1, global_shift: float = 0
-    ):
+    ) -> None:
         """Apply a CX operation to the state.
 
         Args:
@@ -122,7 +122,7 @@ class StabilizerState(
         """
 
     @abc.abstractmethod
-    def apply_global_phase(self, coefficient: linear_dict.Scalar):
+    def apply_global_phase(self, coefficient: linear_dict.Scalar) -> None:
         """Apply a global phase to the state.
 
         Args:
@@ -561,7 +561,7 @@ class CliffordTableau(StabilizerState):
 
         return int(self.rs[p])
 
-    def apply_x(self, axis: int, exponent: float = 1, global_shift: float = 0):
+    def apply_x(self, axis: int, exponent: float = 1, global_shift: float = 0) -> None:
         if exponent % 2 == 0:
             return
         if exponent % 0.5 != 0.0:
@@ -576,7 +576,7 @@ class CliffordTableau(StabilizerState):
             self.rs[:] ^= self.xs[:, axis] & self.zs[:, axis]
             self.xs[:, axis] ^= self.zs[:, axis]
 
-    def apply_y(self, axis: int, exponent: float = 1, global_shift: float = 0):
+    def apply_y(self, axis: int, exponent: float = 1, global_shift: float = 0) -> None:
         if exponent % 2 == 0:
             return
         if exponent % 0.5 != 0.0:
@@ -597,7 +597,7 @@ class CliffordTableau(StabilizerState):
                 self.xs[:, axis].copy(),
             )
 
-    def apply_z(self, axis: int, exponent: float = 1, global_shift: float = 0):
+    def apply_z(self, axis: int, exponent: float = 1, global_shift: float = 0) -> None:
         if exponent % 2 == 0:
             return
         if exponent % 0.5 != 0.0:
@@ -612,7 +612,7 @@ class CliffordTableau(StabilizerState):
             self.rs[:] ^= self.xs[:, axis] & (~self.zs[:, axis])
             self.zs[:, axis] ^= self.xs[:, axis]
 
-    def apply_h(self, axis: int, exponent: float = 1, global_shift: float = 0):
+    def apply_h(self, axis: int, exponent: float = 1, global_shift: float = 0) -> None:
         if exponent % 2 == 0:
             return
         if exponent % 1 != 0:
@@ -622,7 +622,7 @@ class CliffordTableau(StabilizerState):
 
     def apply_cz(
         self, control_axis: int, target_axis: int, exponent: float = 1, global_shift: float = 0
-    ):
+    ) -> None:
         if exponent % 2 == 0:
             return
         if exponent % 1 != 0:
@@ -647,7 +647,7 @@ class CliffordTableau(StabilizerState):
 
     def apply_cx(
         self, control_axis: int, target_axis: int, exponent: float = 1, global_shift: float = 0
-    ):
+    ) -> None:
         if exponent % 2 == 0:
             return
         if exponent % 1 != 0:
@@ -660,7 +660,7 @@ class CliffordTableau(StabilizerState):
         self.xs[:, target_axis] ^= self.xs[:, control_axis]
         self.zs[:, control_axis] ^= self.zs[:, target_axis]
 
-    def apply_global_phase(self, coefficient: linear_dict.Scalar):
+    def apply_global_phase(self, coefficient: linear_dict.Scalar) -> None:
         pass
 
     def measure(

cirq/qis/clifford_tableau_test.py

@@ -47,7 +47,7 @@ def _CNOT(table, q1, q2):
 
 
 @pytest.mark.parametrize('num_qubits', range(1, 4))
-def test_tableau_initial_state_string(num_qubits):
+def test_tableau_initial_state_string(num_qubits) -> None:
     for i in range(2**num_qubits):
         t = cirq.CliffordTableau(initial_state=i, num_qubits=num_qubits)
         splitted_represent_string = str(t).split('\n')
@@ -58,7 +58,7 @@ def test_tableau_initial_state_string(num_qubits):
             assert splitted_represent_string[n] == expected_string
 
 
-def test_tableau_invalid_initial_state():
+def test_tableau_invalid_initial_state() -> None:
     with pytest.raises(ValueError, match="2*num_qubits columns and of type bool."):
         cirq.CliffordTableau(1, rs=np.zeros(1, dtype=bool))
 
@@ -73,7 +73,7 @@ def test_tableau_invalid_initial_state():
         cirq.CliffordTableau(1, zs=np.zeros(1, dtype=bool))
 
 
-def test_stabilizers():
+def test_stabilizers() -> None:
     # Note: the stabilizers are not unique for one state. We just use the one
     # produced by the tableau algorithm.
     # 1. Final state is |1>: Stabalized by -Z.
@@ -101,7 +101,7 @@ def test_stabilizers():
     assert stabilizers[1] == cirq.DensePauliString('IX', coefficient=1)
 
 
-def test_destabilizers():
+def test_destabilizers() -> None:
     # Note: Like stablizers, the destabilizers are not unique for one state, too.
     # We just use the one produced by the tableau algorithm.
     # Under the clifford tableau algorithm, there are several properties that the
@@ -135,7 +135,7 @@ def test_destabilizers():
     assert destabilizers[1] == cirq.DensePauliString('IZ', coefficient=1)
 
 
-def test_measurement():
+def test_measurement() -> None:
     repetitions = 500
     prng = np.random.RandomState(seed=123456)
 
@@ -195,7 +195,7 @@ def test_measurement():
     assert sum(np.asarray(res) == 3) >= (repetitions / 4 * 0.9)
 
 
-def test_validate_tableau():
+def test_validate_tableau() -> None:
     num_qubits = 4
     for i in range(2**num_qubits):
         t = cirq.CliffordTableau(initial_state=i, num_qubits=num_qubits)
@@ -218,7 +218,7 @@ def test_validate_tableau():
     assert not t._validate()
 
 
-def test_rowsum():
+def test_rowsum() -> None:
     # Note: rowsum should not apply on two rows that anti-commute each other.
     t = cirq.CliffordTableau(num_qubits=2)
     # XI * IX ==> XX
@@ -246,7 +246,7 @@ def test_rowsum():
     assert t.stabilizers()[1] == cirq.DensePauliString('YX', coefficient=1)
 
 
-def test_json_dict():
+def test_json_dict() -> None:
     t = cirq.CliffordTableau._from_json_dict_(n=1, rs=[0, 0], xs=[[1], [0]], zs=[[0], [1]])
     assert t.destabilizers()[0] == cirq.DensePauliString('X', coefficient=1)
     assert t.stabilizers()[0] == cirq.DensePauliString('Z', coefficient=1)
@@ -266,7 +266,7 @@ def test_json_dict():
             assert json_dict[k] == v
 
 
-def test_str():
+def test_str() -> None:
     t = cirq.CliffordTableau(num_qubits=2)
     splitted_represent_string = str(t).split('\n')
     assert len(splitted_represent_string) == 2
@@ -288,11 +288,11 @@ def test_str():
     assert splitted_represent_string[1] == '+ I Y '
 
 
-def test_repr():
+def test_repr() -> None:
     cirq.testing.assert_equivalent_repr(cirq.CliffordTableau(num_qubits=1))
 
 
-def test_str_full():
+def test_str_full() -> None:
     t = cirq.CliffordTableau(num_qubits=1)
     expected_str = r"""stable | destable
 -------+----------
@@ -317,7 +317,7 @@ def test_str_full():
     assert t._str_full_() == expected_str
 
 
-def test_copy():
+def test_copy() -> None:
     t = cirq.CliffordTableau(num_qubits=3, initial_state=3)
     new_t = t.copy()
 
@@ -340,7 +340,7 @@ def _three_identical_table(num_qubits):
     return t1, t2, t3
 
 
-def test_tableau_then():
+def test_tableau_then() -> None:
 
     t1, t2, expected_t = _three_identical_table(1)
     assert expected_t == t1.then(t2)
@@ -427,7 +427,7 @@ def test_tableau_then():
     assert expected_t == t1.then(t2)
 
 
-def test_tableau_matmul():
+def test_tableau_matmul() -> None:
     t1, t2, expected_t = _three_identical_table(1)
     _ = [_H(t, 0) for t in (t1, expected_t)]
     _ = [_H(t, 0) for t in (t2, expected_t)]
@@ -443,17 +443,17 @@ def test_tableau_matmul():
         t1 @ 21
 
 
-def test_tableau_then_with_bad_input():
+def test_tableau_then_with_bad_input() -> None:
     t1 = cirq.CliffordTableau(1)
     t2 = cirq.CliffordTableau(2)
     with pytest.raises(ValueError, match="Mismatched number of qubits of two tableaux: 1 vs 2."):
         t1.then(t2)
 
     with pytest.raises(TypeError):
-        t1.then(cirq.X)
+        t1.then(cirq.X)  # type: ignore[arg-type]
 
 
-def test_inverse():
+def test_inverse() -> None:
     t = cirq.CliffordTableau(num_qubits=1)
     assert t.inverse() == t
 

cirq/qis/entropy.py

@@ -93,7 +93,7 @@ def _compute_bitstrings_contribution_to_purity(bitstrings: npt.NDArray[np.int8])
 
 def process_renyi_entropy_from_bitstrings(
     measured_bitstrings: npt.NDArray[np.int8],
-    subsystem: tuple[int] | None = None,
+    subsystem: tuple[int, ...] | None = None,
     pool: ThreadPoolExecutor | None = None,
 ) -> float:
     """Compute the Rényi entropy of an array of bitstrings.

cirq/qis/entropy_test.py

@@ -23,7 +23,7 @@ from cirq.qis.entropy import process_renyi_entropy_from_bitstrings
 
 
 @pytest.mark.parametrize('pool', [None, ThreadPoolExecutor(max_workers=1)])
-def test_process_renyi_entropy_from_bitstrings(pool):
+def test_process_renyi_entropy_from_bitstrings(pool) -> None:
     bitstrings = np.array(
         [
             [[0, 1, 1, 0], [1, 0, 0, 0], [0, 0, 0, 1], [0, 1, 1, 1]],