cirq-core 1.7.0.dev20250911180440__py3-none-any.whl → 1.7.0.dev20250917002151__py3-none-any.whl

cirq/_version.py

@@ -28,4 +28,4 @@ if sys.version_info < (3, 11, 0):  # pragma: no cover
         'of Cirq (e.g. "python -m pip install cirq==1.5.0")'
     )
 
-__version__ = "1.7.0.dev20250911180440"
+__version__ = "1.7.0.dev20250917002151"

cirq/_version_test.py

@@ -3,4 +3,4 @@ import cirq
 
 
 def test_version() -> None:
-    assert cirq.__version__ == "1.7.0.dev20250911180440"
+    assert cirq.__version__ == "1.7.0.dev20250917002151"

cirq/circuits/circuit_operation_test.py

@@ -1253,22 +1253,27 @@ def test_repeat_until_protocols() -> None:
     # Ensure the _repeat_until has been mapped, the measurement has been mapped to the same key,
     # and the control keys of the subcircuit is empty (because the control key of the condition is
     # bound to the measurement).
+    assert scoped._mapped_repeat_until is not None
     assert scoped._mapped_repeat_until.keys == (cirq.MeasurementKey('a', ('0',)),)
     assert cirq.measurement_key_objs(scoped) == {cirq.MeasurementKey('a', ('0',))}
     assert not cirq.control_keys(scoped)
     mapped = cirq.with_measurement_key_mapping(scoped, {'a': 'b'})
+    assert mapped._mapped_repeat_until is not None
     assert mapped._mapped_repeat_until.keys == (cirq.MeasurementKey('b', ('0',)),)
     assert cirq.measurement_key_objs(mapped) == {cirq.MeasurementKey('b', ('0',))}
     assert not cirq.control_keys(mapped)
     prefixed = cirq.with_key_path_prefix(mapped, ('1',))
+    assert prefixed._mapped_repeat_until is not None
     assert prefixed._mapped_repeat_until.keys == (cirq.MeasurementKey('b', ('1', '0')),)
     assert cirq.measurement_key_objs(prefixed) == {cirq.MeasurementKey('b', ('1', '0'))}
     assert not cirq.control_keys(prefixed)
     setpath = cirq.with_key_path(prefixed, ('2',))
+    assert setpath._mapped_repeat_until is not None
     assert setpath._mapped_repeat_until.keys == (cirq.MeasurementKey('b', ('2',)),)
     assert cirq.measurement_key_objs(setpath) == {cirq.MeasurementKey('b', ('2',))}
     assert not cirq.control_keys(setpath)
     resolved = cirq.resolve_parameters(setpath, {'p': 1})
+    assert resolved._mapped_repeat_until is not None
     assert resolved._mapped_repeat_until.keys == (cirq.MeasurementKey('b', ('2',)),)
     assert cirq.measurement_key_objs(resolved) == {cirq.MeasurementKey('b', ('2',))}
     assert not cirq.control_keys(resolved)

cirq/ops/classically_controlled_operation.py

@@ -14,7 +14,7 @@
 
 from __future__ import annotations
 
-from typing import AbstractSet, Any, cast, Mapping, Sequence, TYPE_CHECKING
+from typing import AbstractSet, Any, Mapping, Sequence, TYPE_CHECKING
 
 import sympy
 
@@ -207,17 +207,13 @@ class ClassicallyControlledOperation(raw_types.Operation):
         conditions = [protocols.with_measurement_key_mapping(c, key_map) for c in self._conditions]
         sub_operation = protocols.with_measurement_key_mapping(self._sub_operation, key_map)
         sub_operation = self._sub_operation if sub_operation is NotImplemented else sub_operation
-        return cast(
-            ClassicallyControlledOperation, sub_operation.with_classical_controls(*conditions)
-        )
+        return sub_operation.with_classical_controls(*conditions)
 
     def _with_key_path_prefix_(self, prefix: tuple[str, ...]) -> ClassicallyControlledOperation:
         conditions = [protocols.with_key_path_prefix(c, prefix) for c in self._conditions]
         sub_operation = protocols.with_key_path_prefix(self._sub_operation, prefix)
         sub_operation = self._sub_operation if sub_operation is NotImplemented else sub_operation
-        return cast(
-            ClassicallyControlledOperation, sub_operation.with_classical_controls(*conditions)
-        )
+        return sub_operation.with_classical_controls(*conditions)
 
     def _with_rescoped_keys_(
         self, path: tuple[str, ...], bindable_keys: frozenset[cirq.MeasurementKey]

cirq/ops/gate_operation.py

@@ -331,6 +331,21 @@ class GateOperation(raw_types.Operation):
     def __rmul__(self, other: Any) -> Any:
         return self.gate._rmul_with_qubits(self._qubits, other)
 
+    def __add__(self, other):
+        return 1 * self + other
+
+    def __radd__(self, other):
+        return other + 1 * self
+
+    def __sub__(self, other):
+        return 1 * self - other
+
+    def __rsub__(self, other):
+        return other + -self
+
+    def __neg__(self):
+        return -1 * self
+
     def _qasm_(self, args: protocols.QasmArgs) -> str | None:
         if isinstance(self.gate, ops.GlobalPhaseGate):
             warnings.warn(

cirq/ops/linear_combinations.py

@@ -746,10 +746,6 @@ class PauliSum:
             other = PauliSum.from_pauli_strings([PauliString(coefficient=other)])
         elif isinstance(other, PauliString):
             other = PauliSum.from_pauli_strings([other])
-        elif isinstance(other, raw_types.Operation) and isinstance(
-            other.gate, identity.IdentityGate
-        ):
-            other = PauliSum.from_pauli_strings([PauliString()])
 
         if not isinstance(other, PauliSum):
             return NotImplemented
@@ -758,10 +754,9 @@ class PauliSum:
         return self
 
     def __add__(self, other):
-        if not isinstance(other, (numbers.Complex, PauliString, PauliSum, raw_types.Operation)):
-            return NotImplemented
         result = self.copy()
-        result += other
+        if result.__iadd__(other) is NotImplemented:
+            return NotImplemented
         return result
 
     def __radd__(self, other):
@@ -775,10 +770,6 @@ class PauliSum:
             other = PauliSum.from_pauli_strings([PauliString(coefficient=other)])
         elif isinstance(other, PauliString):
             other = PauliSum.from_pauli_strings([other])
-        elif isinstance(other, raw_types.Operation) and isinstance(
-            other.gate, identity.IdentityGate
-        ):
-            other = PauliSum.from_pauli_strings([PauliString()])
 
         if not isinstance(other, PauliSum):
             return NotImplemented
@@ -787,10 +778,9 @@ class PauliSum:
         return self
 
     def __sub__(self, other):
-        if not isinstance(other, (numbers.Complex, PauliString, PauliSum, raw_types.Operation)):
-            return NotImplemented
         result = self.copy()
-        result -= other
+        if result.__isub__(other) is NotImplemented:
+            return NotImplemented
         return result
 
     def __neg__(self):

cirq/ops/measure_util.py

@@ -14,12 +14,12 @@
 
 from __future__ import annotations
 
-from typing import Callable, Iterable, overload, TYPE_CHECKING
+from typing import Callable, cast, Iterable, overload, TYPE_CHECKING
 
 import numpy as np
 
 from cirq import protocols
-from cirq.ops import pauli_string, raw_types
+from cirq.ops import gate_operation, pauli_string, raw_types
 from cirq.ops.measurement_gate import MeasurementGate
 from cirq.ops.pauli_measurement_gate import PauliMeasurementGate
 
@@ -96,7 +96,7 @@ def measure(
     key: str | cirq.MeasurementKey | None = None,
     invert_mask: tuple[bool, ...] = (),
     confusion_map: dict[tuple[int, ...], np.ndarray] | None = None,
-) -> raw_types.Operation:
+) -> gate_operation.GateOperation:
     pass
 
 
@@ -107,7 +107,7 @@ def measure(
     key: str | cirq.MeasurementKey | None = None,
     invert_mask: tuple[bool, ...] = (),
     confusion_map: dict[tuple[int, ...], np.ndarray] | None = None,
-) -> raw_types.Operation:
+) -> gate_operation.GateOperation:
     pass
 
 
@@ -116,7 +116,7 @@ def measure(
     key: str | cirq.MeasurementKey | None = None,
     invert_mask: tuple[bool, ...] = (),
     confusion_map: dict[tuple[int, ...], np.ndarray] | None = None,
-) -> raw_types.Operation:
+) -> gate_operation.GateOperation:
     """Returns a single MeasurementGate applied to all the given qubits.
 
     The qubits are measured in the computational basis. This can also be
@@ -161,7 +161,8 @@ def measure(
     if key is None:
         key = _default_measurement_key(targets)
     qid_shape = protocols.qid_shape(targets)
-    return MeasurementGate(len(targets), key, invert_mask, qid_shape, confusion_map).on(*targets)
+    gate = MeasurementGate(len(targets), key, invert_mask, qid_shape, confusion_map)
+    return cast(gate_operation.GateOperation, gate.on(*targets))
 
 
 M = measure

cirq/ops/pauli_string_test.py

@@ -2086,12 +2086,13 @@ def test_resolve(resolve_fn) -> None:
     ids=str,
 )
 def test_pauli_ops_identity_gate_operation(gate1: cirq.Pauli, gate2: cirq.Pauli) -> None:
-    # TODO: Issue #7280 - Support addition and subtraction of identity gate operations.
-    if gate1 == gate2 == cirq.I:
-        pytest.skip('Not yet implemented per #7280')
     q = cirq.LineQubit(0)
     pauli1, pauli2 = gate1.on(q), gate2.on(q)
-    unitary1, unitary2 = cirq.unitary(gate1), cirq.unitary(gate2)
+    if gate1 == gate2 == cirq.I:
+        # PauliSum swallows I qubits, so resulting unitaries are dimensionless
+        unitary1 = unitary2 = np.array([[1]])
+    else:
+        unitary1, unitary2 = cirq.unitary(gate1), cirq.unitary(gate2)
     addition = pauli1 + pauli2
     assert isinstance(addition, cirq.PauliSum)
     assert np.array_equal(addition.matrix(), unitary1 + unitary2)
@@ -2100,7 +2101,7 @@ def test_pauli_ops_identity_gate_operation(gate1: cirq.Pauli, gate2: cirq.Pauli)
     assert np.array_equal(subtraction.matrix(), unitary1 - unitary2)
 
 
-def test_pauli_gate_multiplication_with_power():
+def test_pauli_gate_multiplication_with_power() -> None:
     q = cirq.LineQubit(0)
 
     # Test all Pauli gates (X, Y, Z)
@@ -2123,7 +2124,7 @@ def test_pauli_gate_multiplication_with_power():
         assert gate**5 * gate**0 == gate**5
 
 
-def test_try_interpret_as_pauli_string():
+def test_try_interpret_as_pauli_string() -> None:
     from cirq.ops.pauli_string import _try_interpret_as_pauli_string
 
     q = cirq.LineQubit(0)

cirq/ops/raw_types.py

@@ -28,6 +28,7 @@ from typing import (
     Hashable,
     Iterable,
     Mapping,
+    overload,
     Sequence,
     TYPE_CHECKING,
 )
@@ -687,9 +688,17 @@ class Operation(metaclass=abc.ABCMeta):
         """The classical controls gating this operation."""
         return frozenset()
 
+    @overload
+    def with_classical_controls(self) -> cirq.Operation:
+        pass
+
+    @overload
     def with_classical_controls(
         self, *conditions: str | cirq.MeasurementKey | cirq.Condition | sympy.Expr
-    ) -> cirq.Operation:
+    ) -> cirq.ClassicallyControlledOperation:
+        pass
+
+    def with_classical_controls(self, *conditions):
         """Returns a classically controlled version of this operation.
 
         An operation that is classically controlled is executed iff all
@@ -957,9 +966,17 @@ class TaggedOperation(Operation):
         new_sub_operation = self.sub_operation.without_classical_controls()
         return self if new_sub_operation is self.sub_operation else new_sub_operation
 
+    @overload
+    def with_classical_controls(self) -> cirq.Operation:
+        pass
+
+    @overload
     def with_classical_controls(
         self, *conditions: str | cirq.MeasurementKey | cirq.Condition | sympy.Expr
-    ) -> cirq.Operation:
+    ) -> cirq.ClassicallyControlledOperation:
+        pass
+
+    def with_classical_controls(self, *conditions):
         if not conditions:
             return self
         return self.sub_operation.with_classical_controls(*conditions)

cirq/protocols/has_stabilizer_effect_protocol_test.py

@@ -14,6 +14,8 @@
 
 from __future__ import annotations
 
+from typing import Any
+
 import numpy as np
 
 import cirq
@@ -50,40 +52,40 @@ class EmptyOp(cirq.Operation):
         self.q = q
 
     @property
-    def qubits(self):
+    def qubits(self) -> tuple[cirq.Qid, ...]:
         return (self.q,)
 
-    def with_qubits(self, *new_qubits):  # pragma: no cover
+    def with_qubits(self, *new_qubits) -> cirq.Operation:  # pragma: no cover
         return self
 
 
 class NoOp(EmptyOp):
     @property
-    def gate(self):
+    def gate(self) -> Any:
         return No()
 
 
 class NoOp1(EmptyOp):
     @property
-    def gate(self):
+    def gate(self) -> Any:
         return No1()
 
 
 class NoOp2(EmptyOp):
     @property
-    def gate(self):
+    def gate(self) -> Any:
         return No2()
 
 
 class NoOp3(EmptyOp):
     @property
-    def gate(self):
+    def gate(self) -> Any:
         return No3()
 
 
 class YesOp(EmptyOp):
     @property
-    def gate(self):
+    def gate(self) -> Any:
         return Yes()
 
 
@@ -95,8 +97,8 @@ class OpWithUnitary(EmptyOp):
         return self.unitary
 
     @property
-    def qubits(self):
-        return cirq.LineQubit.range(self.unitary.shape[0].bit_length() - 1)
+    def qubits(self) -> tuple[cirq.Qid, ...]:
+        return tuple(cirq.LineQubit.range(self.unitary.shape[0].bit_length() - 1))
 
 
 class GateDecomposes(cirq.Gate):

cirq/protocols/has_unitary_protocol_test.py

@@ -218,8 +218,8 @@ class EmptyOp(cirq.Operation):
     """A trivial operation that will be recognized as `_apply_unitary_`-able."""
 
     @property
-    def qubits(self):
+    def qubits(self) -> tuple[cirq.Qid, ...]:
         return ()
 
-    def with_qubits(self, *new_qubits):  # pragma: no cover
-        return self
+    def with_qubits(self, *new_qubits) -> cirq.Operation:
+        raise NotImplementedError()

cirq/protocols/json_serialization.py

@@ -217,7 +217,7 @@ class CirqEncoder(json.JSONEncoder):
         super().__init__(*args, **kwargs)
         self._memo: dict[Any, dict] = {}
 
-    def default(self, o):
+    def default(self, o) -> dict[str, Any] | list[Any] | float | bool:
         # Object with custom method?
         if hasattr(o, '_json_dict_'):
             json_dict = _json_dict_with_cirq_type(o)
@@ -519,7 +519,7 @@ def read_json(
     *,
     json_text: str | None = None,
     resolvers: Sequence[JsonResolver] | None = None,
-):
+) -> Any:
     """Read a JSON file that optionally contains cirq objects.
 
     Args:
@@ -605,7 +605,7 @@ def read_json_gzip(
     *,
     gzip_raw: bytes | None = None,
     resolvers: Sequence[JsonResolver] | None = None,
-):
+) -> Any:
     """Read a gzipped JSON file that optionally contains cirq objects.
 
     Args:

cirq/protocols/json_serialization_test.py

@@ -72,7 +72,7 @@ def _get_testspecs_for_modules() -> list[ModuleJsonTestSpec]:
 MODULE_TEST_SPECS = _get_testspecs_for_modules()
 
 
-def test_deprecated_cirq_type_in_json_dict():
+def test_deprecated_cirq_type_in_json_dict() -> None:
     class HasOldJsonDict:
         # Required for testing serialization of non-cirq objects.
         __module__ = 'test.noncirq.namespace'
@@ -99,7 +99,7 @@ def test_deprecated_cirq_type_in_json_dict():
         assert_json_roundtrip_works(HasOldJsonDict(), resolvers=test_resolvers)
 
 
-def test_line_qubit_roundtrip():
+def test_line_qubit_roundtrip() -> None:
     q1 = cirq.LineQubit(12)
     assert_json_roundtrip_works(
         q1,
@@ -110,7 +110,7 @@ def test_line_qubit_roundtrip():
     )
 
 
-def test_gridqubit_roundtrip():
+def test_gridqubit_roundtrip() -> None:
     q = cirq.GridQubit(15, 18)
     assert_json_roundtrip_works(
         q,
@@ -122,7 +122,7 @@ def test_gridqubit_roundtrip():
     )
 
 
-def test_op_roundtrip():
+def test_op_roundtrip() -> None:
     q = cirq.LineQubit(5)
     op1 = cirq.rx(0.123).on(q)
     assert_json_roundtrip_works(
@@ -143,7 +143,7 @@ def test_op_roundtrip():
     )
 
 
-def test_op_roundtrip_filename(tmpdir):
+def test_op_roundtrip_filename(tmpdir) -> None:
     filename = f'{tmpdir}/op.json'
     q = cirq.LineQubit(5)
     op1 = cirq.rx(0.123).on(q)
@@ -159,7 +159,7 @@ def test_op_roundtrip_filename(tmpdir):
     assert op1 == op3
 
 
-def test_op_roundtrip_file_obj(tmpdir):
+def test_op_roundtrip_file_obj(tmpdir) -> None:
     filename = f'{tmpdir}/op.json'
     q = cirq.LineQubit(5)
     op1 = cirq.rx(0.123).on(q)
@@ -179,7 +179,7 @@ def test_op_roundtrip_file_obj(tmpdir):
         assert op1 == op3
 
 
-def test_fail_to_resolve():
+def test_fail_to_resolve() -> None:
     buffer = io.StringIO()
     buffer.write(
         """
@@ -207,7 +207,7 @@ Q0, Q1, Q2, Q3, Q4 = QUBITS
 # deprecation error in testing. It is cleaner to just turn it off than to assert
 # deprecation for each submodule.
 @mock.patch.dict(os.environ, clear='CIRQ_TESTING')
-def test_shouldnt_be_serialized_no_superfluous(mod_spec: ModuleJsonTestSpec):
+def test_shouldnt_be_serialized_no_superfluous(mod_spec: ModuleJsonTestSpec) -> None:
     # everything in the list should be ignored for a reason
     names = set(mod_spec.get_all_names())
     missing_names = set(mod_spec.should_not_be_serialized).difference(names)
@@ -223,7 +223,7 @@ def test_shouldnt_be_serialized_no_superfluous(mod_spec: ModuleJsonTestSpec):
 # deprecation error in testing. It is cleaner to just turn it off than to assert
 # deprecation for each submodule.
 @mock.patch.dict(os.environ, clear='CIRQ_TESTING')
-def test_not_yet_serializable_no_superfluous(mod_spec: ModuleJsonTestSpec):
+def test_not_yet_serializable_no_superfluous(mod_spec: ModuleJsonTestSpec) -> None:
     # everything in the list should be ignored for a reason
     names = set(mod_spec.get_all_names())
     missing_names = set(mod_spec.not_yet_serializable).difference(names)
@@ -233,7 +233,7 @@ def test_not_yet_serializable_no_superfluous(mod_spec: ModuleJsonTestSpec):
 
 
 @pytest.mark.parametrize('mod_spec', MODULE_TEST_SPECS, ids=repr)
-def test_mutually_exclusive_not_serialize_lists(mod_spec: ModuleJsonTestSpec):
+def test_mutually_exclusive_not_serialize_lists(mod_spec: ModuleJsonTestSpec) -> None:
     common = set(mod_spec.should_not_be_serialized) & set(mod_spec.not_yet_serializable)
     assert len(common) == 0, (
         f"Defined in both {mod_spec.name} 'Not yet serializable' "
@@ -242,7 +242,7 @@ def test_mutually_exclusive_not_serialize_lists(mod_spec: ModuleJsonTestSpec):
 
 
 @pytest.mark.parametrize('mod_spec', MODULE_TEST_SPECS, ids=repr)
-def test_resolver_cache_vs_should_not_serialize(mod_spec: ModuleJsonTestSpec):
+def test_resolver_cache_vs_should_not_serialize(mod_spec: ModuleJsonTestSpec) -> None:
     resolver_cache_types = set([n for (n, _) in mod_spec.get_resolver_cache_types()])
     common = set(mod_spec.should_not_be_serialized) & resolver_cache_types
 
@@ -254,7 +254,7 @@ def test_resolver_cache_vs_should_not_serialize(mod_spec: ModuleJsonTestSpec):
 
 
 @pytest.mark.parametrize('mod_spec', MODULE_TEST_SPECS, ids=repr)
-def test_resolver_cache_vs_not_yet_serializable(mod_spec: ModuleJsonTestSpec):
+def test_resolver_cache_vs_not_yet_serializable(mod_spec: ModuleJsonTestSpec) -> None:
     resolver_cache_types = set([n for (n, _) in mod_spec.get_resolver_cache_types()])
     common = set(mod_spec.not_yet_serializable) & resolver_cache_types
 
@@ -267,14 +267,14 @@ def test_resolver_cache_vs_not_yet_serializable(mod_spec: ModuleJsonTestSpec):
     )
 
 
-def test_builtins():
+def test_builtins() -> None:
     assert_json_roundtrip_works(True)
     assert_json_roundtrip_works(1)
     assert_json_roundtrip_works(1 + 2j)
     assert_json_roundtrip_works({'test': [123, 5.5], 'key2': 'asdf', '3': None, '0.0': []})
 
 
-def test_numpy():
+def test_numpy() -> None:
     x = np.ones(1)[0]
 
     assert_json_roundtrip_works(np.bool_(True))
@@ -295,7 +295,7 @@ def test_numpy():
     assert_json_roundtrip_works(np.arange(3))
 
 
-def test_pandas():
+def test_pandas() -> None:
     assert_json_roundtrip_works(
         pd.DataFrame(data=[[1, 2, 3], [4, 5, 6]], columns=['x', 'y', 'z'], index=[2, 5])
     )
@@ -320,7 +320,7 @@ def test_pandas():
     )
 
 
-def test_sympy():
+def test_sympy() -> None:
     # Raw values.
     assert_json_roundtrip_works(sympy.Symbol('theta'))
     assert_json_roundtrip_works(sympy.Integer(5))
@@ -388,7 +388,7 @@ class SBKImpl(cirq.SerializableByKey):
         return cls(name, data_list, tuple(data_tuple), data_dict)
 
 
-def test_serializable_by_key():
+def test_serializable_by_key() -> None:
     def custom_resolver(name):
         if name == 'SBKImpl':
             return SBKImpl
@@ -443,12 +443,12 @@ def _list_public_classes_for_tested_modules():
 
 
 @pytest.mark.parametrize('mod_spec,cirq_obj_name,cls', _list_public_classes_for_tested_modules())
-def test_json_test_data_coverage(mod_spec: ModuleJsonTestSpec, cirq_obj_name: str, cls):
+def test_json_test_data_coverage(mod_spec: ModuleJsonTestSpec, cirq_obj_name: str, cls) -> None:
     if cirq_obj_name in mod_spec.tested_elsewhere:
         pytest.skip("Tested elsewhere.")
 
     if cirq_obj_name in mod_spec.not_yet_serializable:
-        return pytest.xfail(reason="Not serializable (yet)")
+        pytest.xfail(reason="Not serializable (yet)")
 
     test_data_path = mod_spec.test_data_path
     rel_path = test_data_path.relative_to(REPO_ROOT)
@@ -529,12 +529,12 @@ class SerializableTypeObject:
 
 
 @pytest.mark.parametrize('mod_spec,cirq_obj_name,cls', _list_public_classes_for_tested_modules())
-def test_type_serialization(mod_spec: ModuleJsonTestSpec, cirq_obj_name: str, cls):
+def test_type_serialization(mod_spec: ModuleJsonTestSpec, cirq_obj_name: str, cls) -> None:
     if cirq_obj_name in mod_spec.tested_elsewhere:
         pytest.skip("Tested elsewhere.")
 
     if cirq_obj_name in mod_spec.not_yet_serializable:
-        return pytest.xfail(reason="Not serializable (yet)")
+        pytest.xfail(reason="Not serializable (yet)")
 
     if cls is None:
         pytest.skip(f'No serialization for None-mapped type: {cirq_obj_name}')  # pragma: no cover
@@ -556,7 +556,7 @@ def test_type_serialization(mod_spec: ModuleJsonTestSpec, cirq_obj_name: str, cl
     assert_json_roundtrip_works(sto, resolvers=test_resolvers)
 
 
-def test_invalid_type_deserialize():
+def test_invalid_type_deserialize() -> None:
     def custom_resolver(name):
         if name == 'SerializableTypeObject':
             return SerializableTypeObject
@@ -571,7 +571,7 @@ def test_invalid_type_deserialize():
         _ = cirq.read_json(json_text=factory_json, resolvers=test_resolvers)
 
 
-def test_to_from_strings():
+def test_to_from_strings() -> None:
     x_json_text = """{
   "cirq_type": "_PauliX",
   "exponent": 1.0,
@@ -584,7 +584,7 @@ def test_to_from_strings():
         cirq.read_json(io.StringIO(), json_text=x_json_text)
 
 
-def test_to_from_json_gzip():
+def test_to_from_json_gzip() -> None:
     a, b = cirq.LineQubit.range(2)
     test_circuit = cirq.Circuit(cirq.H(a), cirq.CX(a, b))
     gzip_data = cirq.to_json_gzip(test_circuit)
@@ -631,7 +631,7 @@ def assert_repr_and_json_test_data_agree(
     json_path: pathlib.Path,
     inward_only: bool,
     deprecation_deadline: str | None,
-):
+) -> None:
     if not repr_path.exists() and not json_path.exists():
         return
 
@@ -701,7 +701,7 @@ def assert_repr_and_json_test_data_agree(
     'mod_spec, abs_path',
     [(m, abs_path) for m in MODULE_TEST_SPECS for abs_path in m.all_test_data_keys()],
 )
-def test_json_and_repr_data(mod_spec: ModuleJsonTestSpec, abs_path: str):
+def test_json_and_repr_data(mod_spec: ModuleJsonTestSpec, abs_path: str) -> None:
     assert_repr_and_json_test_data_agree(
         mod_spec=mod_spec,
         repr_path=pathlib.Path(f'{abs_path}.repr'),
@@ -718,7 +718,7 @@ def test_json_and_repr_data(mod_spec: ModuleJsonTestSpec, abs_path: str):
     )
 
 
-def test_pathlib_paths(tmpdir):
+def test_pathlib_paths(tmpdir) -> None:
     path = pathlib.Path(tmpdir) / 'op.json'
     cirq.to_json(cirq.X, path)
     assert cirq.read_json(path) == cirq.X
@@ -746,7 +746,7 @@ def test_dataclass_json_dict() -> None:
     assert_json_roundtrip_works(my_dc, resolvers=[custom_resolver, *cirq.DEFAULT_RESOLVERS])
 
 
-def test_numpy_values():
+def test_numpy_values() -> None:
     assert (
         cirq.to_json({'value': np.array(1)})
         == """{
@@ -755,7 +755,7 @@ def test_numpy_values():
     )
 
 
-def test_basic_time_assertions():
+def test_basic_time_assertions() -> None:
     naive_dt = datetime.datetime.now()
     utc_dt = naive_dt.astimezone(datetime.timezone.utc)
     assert naive_dt.timestamp() == utc_dt.timestamp()
@@ -768,7 +768,7 @@ def test_basic_time_assertions():
     assert naive_dt == re_naive, 'works, as long as you called fromtimestamp from the same timezone'
 
 
-def test_datetime():
+def test_datetime() -> None:
     naive_dt = datetime.datetime.now()
 
     re_naive_dt = cirq.read_json(json_text=cirq.to_json(naive_dt))
@@ -793,7 +793,7 @@ class _TestAttrsClas:
     x: int
 
 
-def test_attrs_json_dict():
+def test_attrs_json_dict() -> None:
     obj = _TestAttrsClas('test', x=123)
     js = json_serialization.attrs_json_dict(obj)
     assert js == {'name': 'test', 'x': 123}