cirq-core 1.5.0.dev20250409225226__py3-none-any.whl → 1.6.0__py3-none-any.whl

cirq/study/sweeps.py

@@ -11,23 +11,13 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+
+from __future__ import annotations
+
 import abc
 import collections
 import itertools
-from typing import (
-    Any,
-    cast,
-    Dict,
-    Iterable,
-    Iterator,
-    List,
-    Optional,
-    overload,
-    Sequence,
-    Tuple,
-    TYPE_CHECKING,
-    Union,
-)
+from typing import Any, cast, Iterable, Iterator, overload, Sequence, TYPE_CHECKING, Union
 
 import sympy
 
@@ -38,8 +28,8 @@ from cirq.study import resolver
 if TYPE_CHECKING:
     import cirq
 
-Params = Iterable[Tuple['cirq.TParamKey', 'cirq.TParamVal']]
-ProductOrZipSweepLike = Dict['cirq.TParamKey', Union['cirq.TParamVal', Sequence['cirq.TParamVal']]]
+Params = Iterable[tuple['cirq.TParamKey', 'cirq.TParamVal']]
+ProductOrZipSweepLike = dict['cirq.TParamKey', Union['cirq.TParamVal', Sequence['cirq.TParamVal']]]
 
 
 def _check_duplicate_keys(sweeps):
@@ -71,8 +61,8 @@ class Sweep(metaclass=abc.ABCMeta):
     see the Product and Zip documentation.
     """
 
-    def __mul__(self, other: 'Sweep') -> 'Sweep':
-        factors: List[Sweep] = []
+    def __mul__(self, other: Sweep) -> Sweep:
+        factors: list[Sweep] = []
         if isinstance(self, Product):
             factors.extend(self.factors)
         else:
@@ -85,8 +75,8 @@ class Sweep(metaclass=abc.ABCMeta):
             raise TypeError(f'cannot multiply sweep and {type(other)}')
         return Product(*factors)
 
-    def __add__(self, other: 'Sweep') -> 'Sweep':
-        sweeps: List[Sweep] = []
+    def __add__(self, other: Sweep) -> Sweep:
+        sweeps: list[Sweep] = []
         if isinstance(self, Zip):
             sweeps.extend(self.sweeps)
         else:
@@ -108,7 +98,7 @@ class Sweep(metaclass=abc.ABCMeta):
 
     @property
     @abc.abstractmethod
-    def keys(self) -> List['cirq.TParamKey']:
+    def keys(self) -> list[cirq.TParamKey]:
         """The keys for the all of the sympy.Symbols that are resolved."""
 
     @abc.abstractmethod
@@ -119,16 +109,15 @@ class Sweep(metaclass=abc.ABCMeta):
         for params in self.param_tuples():
             yield resolver.ParamResolver(collections.OrderedDict(params))
 
-    # pylint: disable=function-redefined
     @overload
     def __getitem__(self, val: int) -> resolver.ParamResolver:
         pass
 
     @overload
-    def __getitem__(self, val: slice) -> 'Sweep':
+    def __getitem__(self, val: slice) -> Sweep:
         pass
 
-    def __getitem__(self, val: Union[int, slice]) -> Union[resolver.ParamResolver, 'Sweep']:
+    def __getitem__(self, val: int | slice) -> resolver.ParamResolver | Sweep:
         n = len(self)
         if isinstance(val, int):
             if val < -n or val >= n:
@@ -139,7 +128,7 @@ class Sweep(metaclass=abc.ABCMeta):
         if not isinstance(val, slice):
             raise TypeError(f'Sweep indices must be either int or slices, not {type(val)}')
 
-        inds_map: Dict[int, int] = {
+        inds_map: dict[int, int] = {
             sweep_i: slice_i for slice_i, sweep_i in enumerate(range(n)[val])
         }
         results = [resolver.ParamResolver()] * len(inds_map)
@@ -149,8 +138,6 @@ class Sweep(metaclass=abc.ABCMeta):
 
         return ListSweep(results)
 
-    # pylint: enable=function-redefined
-
     @abc.abstractmethod
     def param_tuples(self) -> Iterator[Params]:
         """An iterator over (key, value) pairs assigning Symbol key to value."""
@@ -186,7 +173,7 @@ class _Unit(Sweep):
         return True
 
     @property
-    def keys(self) -> List['cirq.TParamKey']:
+    def keys(self) -> list[cirq.TParamKey]:
         return []
 
     def __len__(self) -> int:
@@ -198,7 +185,7 @@ class _Unit(Sweep):
     def __repr__(self) -> str:
         return 'cirq.UnitSweep'
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return {}
 
 
@@ -233,8 +220,8 @@ class Product(Sweep):
         return hash(tuple(self.factors))
 
     @property
-    def keys(self) -> List['cirq.TParamKey']:
-        return sum((factor.keys for factor in self.factors), [])
+    def keys(self) -> list[cirq.TParamKey]:
+        return list(itertools.chain.from_iterable(factor.keys for factor in self.factors))
 
     def __len__(self) -> int:
         length = 1
@@ -243,16 +230,10 @@ class Product(Sweep):
         return length
 
     def param_tuples(self) -> Iterator[Params]:
-        def _gen(factors):
-            if not factors:
-                yield ()
-            else:
-                first, rest = factors[0], factors[1:]
-                for first_values in first.param_tuples():
-                    for rest_values in _gen(rest):
-                        yield first_values + rest_values
-
-        return _gen(self.factors)
+        yield from map(
+            lambda values: tuple(itertools.chain.from_iterable(values)),
+            itertools.product(*(factor.param_tuples() for factor in self.factors)),
+        )
 
     def __repr__(self) -> str:
         factors_repr = ', '.join(repr(f) for f in self.factors)
@@ -269,7 +250,7 @@ class Product(Sweep):
             factor_strs.append(factor_str)
         return ' * '.join(factor_strs)
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ['factors'])
 
     @classmethod
@@ -308,7 +289,7 @@ class Concat(Sweep):
         return hash(tuple(self.sweeps))
 
     @property
-    def keys(self) -> List['cirq.TParamKey']:
+    def keys(self) -> list[cirq.TParamKey]:
         return self.sweeps[0].keys
 
     def __len__(self) -> int:
@@ -326,7 +307,7 @@ class Concat(Sweep):
         sweeps_repr = ', '.join(repr(s) for s in self.sweeps)
         return f'Concat({sweeps_repr})'
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ['sweeps'])
 
     @classmethod
@@ -361,8 +342,8 @@ class Zip(Sweep):
         return hash(tuple(self.sweeps))
 
     @property
-    def keys(self) -> List['cirq.TParamKey']:
-        return sum((sweep.keys for sweep in self.sweeps), [])
+    def keys(self) -> list[cirq.TParamKey]:
+        return list(itertools.chain.from_iterable(sweep.keys for sweep in self.sweeps))
 
     def __len__(self) -> int:
         if not self.sweeps:
@@ -372,7 +353,7 @@ class Zip(Sweep):
     def param_tuples(self) -> Iterator[Params]:
         iters = [sweep.param_tuples() for sweep in self.sweeps]
         for values in zip(*iters):
-            yield sum(values, ())
+            yield tuple(itertools.chain.from_iterable(values))
 
     def __repr__(self) -> str:
         sweeps_repr = ', '.join(repr(s) for s in self.sweeps)
@@ -383,7 +364,7 @@ class Zip(Sweep):
             return 'Zip()'
         return ' + '.join(str(s) if isinstance(s, Product) else repr(s) for s in self.sweeps)
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ['sweeps'])
 
     @classmethod
@@ -449,7 +430,7 @@ class ZipLongest(Zip):
 class SingleSweep(Sweep):
     """A simple sweep over one parameter with values from an iterator."""
 
-    def __init__(self, key: 'cirq.TParamKey') -> None:
+    def __init__(self, key: cirq.TParamKey) -> None:
         if isinstance(key, sympy.Symbol):
             key = str(key)
         self.key = key
@@ -463,11 +444,11 @@ class SingleSweep(Sweep):
         return hash((self.__class__, self._tuple()))
 
     @abc.abstractmethod
-    def _tuple(self) -> Tuple[Any, ...]:
+    def _tuple(self) -> tuple[Any, ...]:
         pass
 
     @property
-    def keys(self) -> List['cirq.TParamKey']:
+    def keys(self) -> list[cirq.TParamKey]:
         return [self.key]
 
     def param_tuples(self) -> Iterator[Params]:
@@ -483,7 +464,7 @@ class Points(SingleSweep):
     """A simple sweep with explicitly supplied values."""
 
     def __init__(
-        self, key: 'cirq.TParamKey', points: Sequence[float], metadata: Optional[Any] = None
+        self, key: cirq.TParamKey, points: Sequence[float], metadata: Any | None = None
     ) -> None:
         """Creates a sweep on a variable with supplied values.
 
@@ -500,7 +481,7 @@ class Points(SingleSweep):
         self.points = points
         self.metadata = metadata
 
-    def _tuple(self) -> Tuple[Union[str, sympy.Expr], Sequence[float]]:
+    def _tuple(self) -> tuple[str | sympy.Expr, Sequence[float]]:
         return self.key, tuple(self.points)
 
     def __len__(self) -> int:
@@ -513,7 +494,7 @@ class Points(SingleSweep):
         metadata_repr = f', metadata={self.metadata!r}' if self.metadata is not None else ""
         return f'cirq.Points({self.key!r}, {self.points!r}{metadata_repr})'
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         if self.metadata is not None:
             return protocols.obj_to_dict_helper(self, ["key", "points", "metadata"])
         return protocols.obj_to_dict_helper(self, ["key", "points"])
@@ -524,11 +505,11 @@ class Linspace(SingleSweep):
 
     def __init__(
         self,
-        key: 'cirq.TParamKey',
+        key: cirq.TParamKey,
         start: float,
         stop: float,
         length: int,
-        metadata: Optional[Any] = None,
+        metadata: Any | None = None,
     ) -> None:
         """Creates a linear-spaced sweep for a given key.
 
@@ -549,7 +530,7 @@ class Linspace(SingleSweep):
         self.length = length
         self.metadata = metadata
 
-    def _tuple(self) -> Tuple[Union[str, sympy.Expr], float, float, int]:
+    def _tuple(self) -> tuple[str | sympy.Expr, float, float, int]:
         return (self.key, self.start, self.stop, self.length)
 
     def __len__(self) -> int:
@@ -570,7 +551,7 @@ class Linspace(SingleSweep):
             f'stop={self.stop!r}, length={self.length!r}{metadata_repr})'
         )
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         if self.metadata is not None:
             return protocols.obj_to_dict_helper(
                 self, ["key", "start", "stop", "length", "metadata"]
@@ -592,7 +573,7 @@ class ListSweep(Sweep):
             TypeError: If `resolver_list` is not a `cirq.ParamResolver` or a
                 dict.
         """
-        self.resolver_list: List[resolver.ParamResolver] = []
+        self.resolver_list: list[resolver.ParamResolver] = []
         for r in resolver_list:
             if not isinstance(r, (dict, resolver.ParamResolver)):
                 raise TypeError(f'Not a ParamResolver or dict: <{r!r}>')
@@ -607,7 +588,7 @@ class ListSweep(Sweep):
         return not self == other
 
     @property
-    def keys(self) -> List['cirq.TParamKey']:
+    def keys(self) -> list[cirq.TParamKey]:
         if not self.resolver_list:
             return []
         return list(map(str, self.resolver_list[0].param_dict))
@@ -622,7 +603,7 @@ class ListSweep(Sweep):
     def __repr__(self) -> str:
         return f'cirq.ListSweep({self.resolver_list!r})'
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ["resolver_list"])
 
 

cirq/study/sweeps_test.py

@@ -11,6 +11,9 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+
+from __future__ import annotations
+
 import pytest
 import sympy
 
@@ -76,6 +79,11 @@ def test_zip():
     assert len(sweep) == 3
     assert _values(sweep, 'a') == [1, 2, 3]
     assert _values(sweep, 'b') == [4, 5, 6]
+    assert list(sweep.param_tuples()) == [
+        (('a', 1), ('b', 4)),
+        (('a', 2), ('b', 5)),
+        (('a', 3), ('b', 6)),
+    ]
 
 
 def test_zip_longest():
@@ -150,6 +158,30 @@ def test_product():
     assert _values(sweep, 'b') == [3, 3, 4, 4, 3, 3, 4, 4]
     assert _values(sweep, 'c') == [5, 6, 5, 6, 5, 6, 5, 6]
 
+    sweep = cirq.Points('a', [1, 2]) * (cirq.Points('b', [3, 4, 5]))
+    assert list(map(list, sweep.param_tuples())) == [
+        [('a', 1), ('b', 3)],
+        [('a', 1), ('b', 4)],
+        [('a', 1), ('b', 5)],
+        [('a', 2), ('b', 3)],
+        [('a', 2), ('b', 4)],
+        [('a', 2), ('b', 5)],
+    ]
+
+    sweep = cirq.Product(*[cirq.Points(str(i), [0]) for i in range(1025)])
+    assert list(map(list, sweep.param_tuples())) == [[(str(i), 0) for i in range(1025)]]
+
+
+def test_nested_product_zip():
+    sweep = cirq.Product(
+        cirq.Product(cirq.Points('a', [0]), cirq.Points('b', [0])),
+        cirq.Zip(cirq.Points('c', [0, 1]), cirq.Points('d', [0, 1])),
+    )
+    assert list(map(list, sweep.param_tuples())) == [
+        [('a', 0), ('b', 0), ('c', 0), ('d', 0)],
+        [('a', 0), ('b', 0), ('c', 1), ('d', 1)],
+    ]
+
 
 def test_zip_addition():
     zip_sweep = cirq.Zip(cirq.Points('a', [1, 2]), cirq.Points('b', [3, 4]))
@@ -164,6 +196,7 @@ def test_empty_product():
     sweep = cirq.Product()
     assert len(sweep) == len(list(sweep)) == 1
     assert str(sweep) == 'Product()'
+    assert list(map(list, sweep.param_tuples())) == [[]]
 
 
 def test_slice_access_error():

cirq/testing/__init__.py

@@ -15,12 +15,11 @@
 """Utilities for testing code."""
 
 from cirq.testing.circuit_compare import (
-    # pylint: disable=line-too-long
-    assert_circuits_with_terminal_measurements_are_equivalent as assert_circuits_with_terminal_measurements_are_equivalent,
-    assert_circuits_have_same_unitary_given_final_permutation as assert_circuits_have_same_unitary_given_final_permutation,
+    assert_circuits_with_terminal_measurements_are_equivalent as assert_circuits_with_terminal_measurements_are_equivalent,  # noqa: E501
+    assert_circuits_have_same_unitary_given_final_permutation as assert_circuits_have_same_unitary_given_final_permutation,  # noqa: E501
     assert_has_consistent_apply_channel as assert_has_consistent_apply_channel,
     assert_has_consistent_apply_unitary as assert_has_consistent_apply_unitary,
-    assert_has_consistent_apply_unitary_for_various_exponents as assert_has_consistent_apply_unitary_for_various_exponents,
+    assert_has_consistent_apply_unitary_for_various_exponents as assert_has_consistent_apply_unitary_for_various_exponents,  # noqa: E501
     assert_has_diagram as assert_has_diagram,
     assert_same_circuits as assert_same_circuits,
     highlight_text_differences as highlight_text_differences,
@@ -28,8 +27,7 @@ from cirq.testing.circuit_compare import (
 )
 
 from cirq.testing.consistent_act_on import (
-    # pylint: disable=line-too-long
-    assert_all_implemented_act_on_effects_match_unitary as assert_all_implemented_act_on_effects_match_unitary,
+    assert_all_implemented_act_on_effects_match_unitary as assert_all_implemented_act_on_effects_match_unitary,  # noqa: E501
 )
 
 from cirq.testing.consistent_channels import (
@@ -48,8 +46,7 @@ from cirq.testing.consistent_decomposition import (
 )
 
 from cirq.testing.consistent_pauli_expansion import (
-    # pylint: disable=line-too-long
-    assert_pauli_expansion_is_consistent_with_unitary as assert_pauli_expansion_is_consistent_with_unitary,
+    assert_pauli_expansion_is_consistent_with_unitary as assert_pauli_expansion_is_consistent_with_unitary,  # noqa: E501
 )
 
 from cirq.testing.consistent_phase_by import (
@@ -57,11 +54,10 @@ from cirq.testing.consistent_phase_by import (
 )
 
 from cirq.testing.consistent_protocols import (
-    # pylint: disable=line-too-long
-    assert_eigengate_implements_consistent_protocols as assert_eigengate_implements_consistent_protocols,
+    assert_eigengate_implements_consistent_protocols as assert_eigengate_implements_consistent_protocols,  # noqa: E501
     assert_has_consistent_trace_distance_bound as assert_has_consistent_trace_distance_bound,
     assert_implements_consistent_protocols as assert_implements_consistent_protocols,
-    assert_commutes_magic_method_consistent_with_unitaries as assert_commutes_magic_method_consistent_with_unitaries,
+    assert_commutes_magic_method_consistent_with_unitaries as assert_commutes_magic_method_consistent_with_unitaries,  # noqa: E501
 )
 
 from cirq.testing.consistent_qasm import (

cirq/testing/_compat_test_data/module_a/__init__.py

@@ -1,4 +1,5 @@
 # pylint: disable=wrong-or-nonexistent-copyright-notice
+# ruff: noqa: F401
 """module_a for module deprecation tests"""
 
 import logging

cirq/testing/_compat_test_data/module_a/module_b/__init__.py

@@ -1,4 +1,5 @@
 # pylint: disable=wrong-or-nonexistent-copyright-notice
+# ruff: noqa: F401
 from cirq.testing._compat_test_data.module_a.module_b import module_c
 
 MODULE_B_ATTRIBUTE = "module_b"

cirq/testing/_compat_test_data/module_a/sub/__init__.py

@@ -1,2 +1,3 @@
 # pylint: disable=wrong-or-nonexistent-copyright-notice
+# ruff: noqa: F401
 from cirq.testing._compat_test_data.module_a.sub.subsub import dupe

cirq/testing/circuit_compare.py

@@ -12,10 +12,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import itertools
 import random
 from collections import defaultdict
-from typing import Any, Dict, Iterable, List, Optional, Sequence, Union
+from typing import Any, Iterable, Sequence
 
 import numpy as np
 import sympy
@@ -78,7 +80,7 @@ def _measurement_subspaces(
         measurement_mask |= 1 << i
 
     # Keyed by computational basis state with lowest index.
-    measurement_subspaces: Dict[int, List[int]] = defaultdict(list)
+    measurement_subspaces: dict[int, list[int]] = defaultdict(list)
     computational_basis = range(1 << n_qubits)
 
     for basis_state in computational_basis:
@@ -115,9 +117,7 @@ def assert_circuits_with_terminal_measurements_are_equivalent(
         reference: A circuit with the correct function.
         atol: Absolute error tolerance.
     """
-    # pylint: disable=unused-variable
     __tracebackhide__ = True
-    # pylint: enable=unused-variable
 
     measured_qubits_actual = {
         qubit
@@ -213,7 +213,7 @@ def assert_same_circuits(
 
 def _first_differing_moment_index(
     circuit1: circuits.AbstractCircuit, circuit2: circuits.AbstractCircuit
-) -> Optional[int]:
+) -> int | None:
     for i, (m1, m2) in enumerate(itertools.zip_longest(circuit1, circuit2)):
         if m1 != m2:
             return i
@@ -223,7 +223,7 @@ def _first_differing_moment_index(
 def assert_circuits_have_same_unitary_given_final_permutation(
     actual: circuits.AbstractCircuit,
     expected: circuits.AbstractCircuit,
-    qubit_map: Dict[ops.Qid, ops.Qid],
+    qubit_map: dict[ops.Qid, ops.Qid],
 ) -> None:
     """Asserts two circuits have the same unitary up to a final permutation of qubits.
 
@@ -255,7 +255,7 @@ def assert_circuits_have_same_unitary_given_final_permutation(
 
 
 def assert_has_diagram(
-    actual: Union[circuits.AbstractCircuit, circuits.Moment], desired: str, **kwargs
+    actual: circuits.AbstractCircuit | circuits.Moment, desired: str, **kwargs
 ) -> None:
     """Determines if a given circuit has the desired text diagram.
 
@@ -265,9 +265,7 @@ def assert_has_diagram(
             beginning and whitespace at the end are ignored.
         **kwargs: Keyword arguments to be passed to actual.to_text_diagram().
     """
-    # pylint: disable=unused-variable
     __tracebackhide__ = True
-    # pylint: enable=unused-variable
     actual_diagram = actual.to_text_diagram(**kwargs).lstrip("\n").rstrip()
     desired_diagram = desired.lstrip("\n").rstrip()
 
@@ -295,9 +293,7 @@ def assert_has_consistent_apply_unitary(val: Any, *, atol: float = 1e-8) -> None
         val: The value under test. Should have a `__pow__` method.
         atol: Absolute error tolerance.
     """
-    # pylint: disable=unused-variable
     __tracebackhide__ = True
-    # pylint: enable=unused-variable
 
     _assert_apply_unitary_works_when_axes_transposed(val, atol=atol)
 
@@ -339,9 +335,8 @@ def assert_has_consistent_apply_channel(val: Any, *, atol: float = 1e-8) -> None
         val: The value under test. Should have a `__pow__` method.
         atol: Absolute error tolerance.
     """
-    # pylint: disable=unused-variable
     __tracebackhide__ = True
-    # pylint: enable=unused-variable
+    assert hasattr(val, '_apply_channel_')
 
     kraus = protocols.kraus(val, default=None)
     expected = qis.kraus_to_superoperator(kraus) if kraus is not None else None
@@ -461,9 +456,7 @@ def assert_has_consistent_apply_unitary_for_various_exponents(
             the value's `__pow__` returns `NotImplemented` for any of these,
             they are skipped.
     """
-    # pylint: disable=unused-variable
     __tracebackhide__ = True
-    # pylint: enable=unused-variable
 
     for exponent in exponents:
         gate = protocols.pow(val, exponent, default=None)
@@ -483,9 +476,7 @@ def assert_has_consistent_qid_shape(val: Any) -> None:
         val: The value under test. Should have `_qid_shape_` and/or
             `num_qubits_` methods. Can optionally have a `qubits` property.
     """
-    # pylint: disable=unused-variable
     __tracebackhide__ = True
-    # pylint: enable=unused-variable
     default = (-1,)
     qid_shape = protocols.qid_shape(val, default)
     num_qubits = protocols.num_qubits(val, default)

cirq/testing/circuit_compare_test.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import numpy as np
 import pytest
 

cirq/testing/consistent_act_on.py

@@ -12,7 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Any, cast, Optional, Type
+from __future__ import annotations
+
+from typing import Any, cast, TYPE_CHECKING
 
 import numpy as np
 
@@ -20,7 +22,6 @@ from cirq import protocols
 from cirq.circuits.circuit import Circuit
 from cirq.devices import LineQubit
 from cirq.ops import common_gates
-from cirq.ops.dense_pauli_string import DensePauliString
 from cirq.qis import clifford_tableau
 from cirq.sim import final_state_vector, state_vector_simulation_state
 from cirq.sim.clifford import (
@@ -29,8 +30,13 @@ from cirq.sim.clifford import (
     stabilizer_state_ch_form,
 )
 
+if TYPE_CHECKING:
+    import cirq
+
 
-def state_vector_has_stabilizer(state_vector: np.ndarray, stabilizer: DensePauliString) -> bool:
+def state_vector_has_stabilizer(
+    state_vector: np.ndarray, stabilizer: cirq.DensePauliString
+) -> bool:
     """Checks that the state_vector is stabilized by the given stabilizer.
 
     The stabilizer should not modify the value of the state_vector, up to the
@@ -46,9 +52,9 @@ def state_vector_has_stabilizer(state_vector: np.ndarray, stabilizer: DensePauli
     """
 
     qubits = LineQubit.range(protocols.num_qubits(stabilizer))
-    complex_dtype: Type[np.complexfloating] = np.complex64
+    complex_dtype: type[np.complexfloating] = np.complex64
     if np.issubdtype(state_vector.dtype, np.complexfloating):
-        complex_dtype = cast(Type[np.complexfloating], state_vector.dtype)
+        complex_dtype = cast(type[np.complexfloating], state_vector.dtype)
     args = state_vector_simulation_state.StateVectorSimulationState(
         available_buffer=np.empty_like(state_vector),
         qubits=qubits,
@@ -79,9 +85,7 @@ def assert_all_implemented_act_on_effects_match_unitary(
           val and StabilizerChFormSimulationState inputs.
     """
 
-    # pylint: disable=unused-variable
     __tracebackhide__ = True
-    # pylint: enable=unused-variable
 
     num_qubits_val = protocols.num_qubits(val)
 
@@ -145,9 +149,7 @@ def assert_all_implemented_act_on_effects_match_unitary(
         )
 
 
-def _final_clifford_tableau(
-    circuit: Circuit, qubit_map
-) -> Optional[clifford_tableau.CliffordTableau]:
+def _final_clifford_tableau(circuit: Circuit, qubit_map) -> clifford_tableau.CliffordTableau | None:
     """Evolves a default CliffordTableau through the input circuit.
 
     Initializes a CliffordTableau with default args for the given qubits and
@@ -175,7 +177,7 @@ def _final_clifford_tableau(
 
 def _final_stabilizer_state_ch_form(
     circuit: Circuit, qubit_map
-) -> Optional[stabilizer_state_ch_form.StabilizerStateChForm]:
+) -> stabilizer_state_ch_form.StabilizerStateChForm | None:
     """Evolves a default StabilizerStateChForm through the input circuit.
 
     Initializes a StabilizerStateChForm with default args for the given qubits

cirq/testing/consistent_act_on_test.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 from typing import Sequence
 
 import numpy as np
@@ -24,7 +26,7 @@ class GoodGate(cirq.testing.SingleQubitGate):
     def _unitary_(self):
         return np.array([[0, 1], [1, 0]])
 
-    def _act_on_(self, sim_state: 'cirq.SimulationStateBase', qubits: Sequence['cirq.Qid']):
+    def _act_on_(self, sim_state: cirq.SimulationStateBase, qubits: Sequence[cirq.Qid]):
         if isinstance(sim_state, cirq.CliffordTableauSimulationState):
             tableau = sim_state.tableau
             q = sim_state.qubit_map[qubits[0]]
@@ -37,7 +39,7 @@ class BadGate(cirq.testing.SingleQubitGate):
     def _unitary_(self):
         return np.array([[0, 1j], [1, 0]])
 
-    def _act_on_(self, sim_state: 'cirq.SimulationStateBase', qubits: Sequence['cirq.Qid']):
+    def _act_on_(self, sim_state: cirq.SimulationStateBase, qubits: Sequence[cirq.Qid]):
         if isinstance(sim_state, cirq.CliffordTableauSimulationState):
             tableau = sim_state.tableau
             q = sim_state.qubit_map[qubits[0]]
@@ -55,7 +57,7 @@ class UnimplementedUnitaryGate(cirq.testing.TwoQubitGate):
         return np.array([[0, 0, 0, 1], [0, 0, 1, 0], [0, 1, 0, 0], [1, 0, 0, 0]])
 
 
-def test_assert_act_on_clifford_tableau_effect_matches_unitary():
+def test_assert_act_on_clifford_tableau_effect_matches_unitary() -> None:
     cirq.testing.assert_all_implemented_act_on_effects_match_unitary(GoodGate())
     cirq.testing.assert_all_implemented_act_on_effects_match_unitary(
         GoodGate().on(cirq.LineQubit(1))

cirq/testing/consistent_channels.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 from typing import Any
 
 import numpy as np