cirq-core 1.7.0.dev20250825174419__py3-none-any.whl → 1.7.0.dev20251203004401__py3-none-any.whl

cirq/protocols/resolve_parameters.py

@@ -15,7 +15,8 @@
 from __future__ import annotations
 
 import numbers
-from typing import AbstractSet, Any, cast, Protocol, Self, TYPE_CHECKING, TypeVar
+from collections.abc import Set
+from typing import Any, cast, Protocol, Self, TYPE_CHECKING, TypeVar
 
 import sympy
 
@@ -40,7 +41,7 @@ class SupportsParameterization(Protocol):
         and False otherwise."""
 
     @doc_private
-    def _parameter_names_(self) -> AbstractSet[str]:
+    def _parameter_names_(self) -> Set[str]:
         """Returns a collection of string names of parameters that require
         resolution. If _is_parameterized_ is False, the collection is empty.
         The converse is not necessarily true, because some objects may report
@@ -92,7 +93,7 @@ def is_parameterized(val: Any) -> bool:
     return bool(parameter_names(val))
 
 
-def parameter_names(val: Any) -> AbstractSet[str]:
+def parameter_names(val: Any) -> Set[str]:
     """Returns parameter names for this object.
 
     Args:
@@ -119,7 +120,7 @@ def parameter_names(val: Any) -> AbstractSet[str]:
     return set()
 
 
-def parameter_symbols(val: Any) -> AbstractSet[sympy.Symbol]:
+def parameter_symbols(val: Any) -> Set[sympy.Symbol]:
     """Returns parameter symbols for this object.
 
     Args:
@@ -169,14 +170,8 @@ def resolve_parameters(
         return val
 
     # Ensure it is a dictionary wrapped in a ParamResolver.
-    param_resolver = study.ParamResolver(param_resolver)
-
-    # Handle special cases for sympy expressions and sequences.
-    # These may not in fact preserve types, but we pretend they do by casting.
-    if isinstance(val, sympy.Expr):
-        return cast(T, param_resolver.value_of(val, recursive))
-    if isinstance(val, (list, tuple)):
-        return cast(T, type(val)(resolve_parameters(e, param_resolver, recursive) for e in val))
+    if not isinstance(param_resolver, study.ParamResolver):
+        param_resolver = study.ParamResolver(param_resolver)
 
     is_parameterized = (
         val._is_parameterized_() if hasattr(val, '_is_parameterized_') else NotImplemented
@@ -192,10 +187,17 @@ def resolve_parameters(
 
     if result is not NotImplemented:
         return result
-    else:
-        return val
+
+    # Handle special cases for sympy expressions and sequences.
+    # These may not in fact preserve types, but we pretend they do by casting.
+    if isinstance(val, sympy.Expr):
+        return cast(T, param_resolver.value_of(val, recursive))
+    if isinstance(val, (list, tuple)):
+        return cast(T, type(val)(resolve_parameters(e, param_resolver, recursive) for e in val))
+
+    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/trace_distance_bound.py

@@ -14,7 +14,8 @@
 
 from __future__ import annotations
 
-from typing import Any, Protocol, Sequence, TypeVar
+from collections.abc import Sequence
+from typing import Any, Protocol, TypeVar
 
 import numpy as np
 

cirq/protocols/unitary_protocol.py

@@ -24,7 +24,7 @@ from cirq.protocols import qid_shape_protocol
 from cirq.protocols.apply_unitary_protocol import apply_unitaries, ApplyUnitaryArgs
 from cirq.protocols.decompose_protocol import _try_decompose_into_operations_and_qubits
 
-# This is a special indicator value used by the unitary method to determine
+# This is a special indicator value used by the function unitary() to determine
 # whether or not the caller provided a 'default' argument. It must be of type
 # np.ndarray to ensure the method has the correct type signature in that case.
 # It is checked for using `is`, so it won't have a false positive if the user
@@ -38,23 +38,23 @@ class SupportsUnitary(Protocol):
     """An object that may be describable by a unitary matrix."""
 
     @doc_private
-    def _unitary_(self) -> np.ndarray | NotImplementedType:
+    def _unitary_(self) -> np.ndarray | NotImplementedType | None:
         """A unitary matrix describing this value, e.g. the matrix of a gate.
 
         This method is used by the global `cirq.unitary` method. If this method
         is not present, or returns NotImplemented, it is assumed that the
         receiving object doesn't have a unitary matrix (resulting in a TypeError
-        or default result when calling `cirq.unitary` on it). (The ability to
+        or default result when calling `cirq.unitary` on it). The ability to
         return NotImplemented is useful when a class cannot know if it has a
-        matrix until runtime, e.g. cirq.X**c normally has a matrix but
-        cirq.X**sympy.Symbol('a') doesn't.)
+        matrix until runtime; e.g., `cirq.X**c` normally has a matrix but
+        `cirq.X**sympy.Symbol('a')` doesn't.
 
         The order of cells in the matrix is always implicit with respect to the
-        object being called. For example, for gates the matrix must be ordered
+        object being called. For example, for gates, the matrix must be ordered
         with respect to the list of qubits that the gate is applied to. For
         operations, the matrix is ordered to match the list returned by its
         `qubits` attribute. The qubit-to-amplitude order mapping matches the
-        ordering of numpy.kron(A, B), where A is a qubit earlier in the list
+        ordering of `numpy.kron(A, B)`, where A is a qubit earlier in the list
         than the qubit B.
 
         Returns:
@@ -68,7 +68,7 @@ class SupportsUnitary(Protocol):
 
         This method is used by the global `cirq.has_unitary` method.  If this
         method is not present, or returns NotImplemented, it will fallback
-        to using _unitary_ with a default value, or False if neither exist.
+        to using `_unitary_()` with a default value, or False if neither exist.
 
         Returns:
             True if the value has a unitary matrix representation, False
@@ -81,17 +81,17 @@ def unitary(
 ) -> np.ndarray | TDefault:
     """Returns a unitary matrix describing the given value.
 
-    The matrix is determined by any one of the following techniques:
+    The matrix is determined by the first of these strategies that succeeds:
 
-    - If the value is a numpy array, it is returned directly.
-    - The value has a `_unitary_` method that returns something besides None or
-        NotImplemented. The matrix is whatever the method returned.
+    - If the value is a NumPy array, it is returned directly.
+    - The value has a `_unitary_` method that returns something besides `None` or
+        `NotImplemented`. The matrix is whatever the method returned.
+    - The value has an `_apply_unitary_` method, and it returns something
+        besides `None` or `NotImplemented`. The matrix is created by applying
+        `_apply_unitary_` to an identity matrix.
     - The value has a `_decompose_` method that returns a list of operations,
         and each operation in the list has a unitary effect. The matrix is
         created by aggregating the sub-operations' unitary effects.
-    - The value has an `_apply_unitary_` method, and it returns something
-        besides None or NotImplemented. The matrix is created by applying
-        `_apply_unitary_` to an identity matrix.
 
     If none of these techniques succeeds, it is assumed that `val` doesn't have
     a unitary effect. The order in which techniques are attempted is
@@ -100,8 +100,8 @@ def unitary(
     Args:
         val: The value to describe with a unitary matrix.
         default: Determines the fallback behavior when `val` doesn't have
-            a unitary effect. If `default` is not set, a TypeError is raised. If
-            `default` is set to a value, that value is returned.
+            a unitary effect. If `default` is not set, a `TypeError` is raised.
+            If `default` is set to a value, that value is returned.
 
     Returns:
         If `val` has a unitary effect, the corresponding unitary matrix.
@@ -135,13 +135,13 @@ def unitary(
         f"type: {type(val)}\n"
         f"value: {val!r}\n"
         "\n"
-        "The value failed to satisfy any of the following criteria:\n"
+        "The given value failed to satisfy any of the following criteria:\n"
         "- A `_unitary_(self)` method that returned a value "
-        "besides None or NotImplemented.\n"
+        "besides `None` or `NotImplemented`.\n"
         "- A `_decompose_(self)` method that returned a "
         "list of unitary operations.\n"
-        "- An `_apply_unitary_(self, args) method that returned a value "
-        "besides None or NotImplemented."
+        "- An `_apply_unitary_(self, args)` method that returned a value "
+        "besides `None` or `NotImplemented`."
     )
 
 

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/channels.py

@@ -16,7 +16,7 @@
 
 from __future__ import annotations
 
-from typing import Sequence
+from collections.abc import Sequence
 
 import numpy as np
 

cirq/qis/channels_test.py

@@ -16,7 +16,7 @@
 
 from __future__ import annotations
 
-from typing import Iterable, Sequence
+from collections.abc import Iterable, Sequence
 
 import numpy as np
 import pytest

cirq/qis/clifford_tableau.py

@@ -15,7 +15,8 @@
 from __future__ import annotations
 
 import abc
-from typing import Any, Sequence, TYPE_CHECKING
+from collections.abc import Sequence
+from typing import Any, TYPE_CHECKING
 
 import numpy as np
 
@@ -38,7 +39,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 +52,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 +65,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 +78,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 +93,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 +109,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 +123,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 +562,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 +577,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 +598,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 +613,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 +623,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 +648,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 +661,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

@@ -14,10 +14,10 @@
 
 from __future__ import annotations
 
-from collections.abc import Sequence
+from collections.abc import Iterator, Sequence
 from concurrent.futures import ThreadPoolExecutor
 from itertools import product
-from typing import Any, cast, Iterator
+from typing import Any, cast
 
 import numpy as np
 import numpy.typing as npt
@@ -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]],

cirq/qis/quantum_state_representation.py

@@ -15,7 +15,8 @@
 from __future__ import annotations
 
 import abc
-from typing import Self, Sequence, TYPE_CHECKING
+from collections.abc import Sequence
+from typing import Self, TYPE_CHECKING
 
 import numpy as np
 

cirq/qis/states.py

@@ -17,7 +17,8 @@
 from __future__ import annotations
 
 import itertools
-from typing import Any, cast, Iterable, Sequence, TYPE_CHECKING, Union
+from collections.abc import Iterable, Sequence
+from typing import Any, cast, TYPE_CHECKING, Union
 
 import numpy as np
 
@@ -1019,7 +1020,11 @@ def validate_density_matrix(
     if not np.isclose(trace, 1.0, atol=atol):
         raise ValueError(f'Density matrix does not have trace 1. Instead, it has trace {trace}.')
     if not np.all(np.linalg.eigvalsh(density_matrix) > -atol):
-        raise ValueError('The density matrix is not positive semidefinite.')
+        raise ValueError(
+            'The density matrix is not positive semidefinite. '
+            'This may happen for simulations using lower-precision `dtype` such as '
+            '`np.complex64`. Try using `np.complex128` in such a case.'
+        )
 
 
 def _qid_shape_from_args(