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

cirq/ops/gate_operation.py

@@ -14,33 +14,21 @@
 
 """Basic types defining qubits, gates, and operations."""
 
+from __future__ import annotations
+
 import re
 import warnings
 from types import NotImplementedType
-from typing import (
-    AbstractSet,
-    Any,
-    cast,
-    Collection,
-    Dict,
-    FrozenSet,
-    List,
-    Mapping,
-    Optional,
-    Sequence,
-    Tuple,
-    TYPE_CHECKING,
-    TypeVar,
-    Union,
-)
-
-import numpy as np
+from typing import AbstractSet, Any, cast, Collection, Mapping, Sequence, TYPE_CHECKING, TypeVar
+
 from typing_extensions import Self
 
 from cirq import ops, protocols, value
 from cirq.ops import control_values as cv, gate_features, raw_types
 
 if TYPE_CHECKING:
+    import numpy as np
+
     import cirq
 
 
@@ -51,7 +39,7 @@ class GateOperation(raw_types.Operation):
     Objects of this type are immutable.
     """
 
-    def __init__(self, gate: 'cirq.Gate', qubits: Sequence['cirq.Qid']) -> None:
+    def __init__(self, gate: cirq.Gate, qubits: Sequence[cirq.Qid]) -> None:
         """Inits GateOperation.
 
         Args:
@@ -63,19 +51,19 @@ class GateOperation(raw_types.Operation):
         self._qubits = tuple(qubits)
 
     @property
-    def gate(self) -> 'cirq.Gate':
+    def gate(self) -> cirq.Gate:
         """The gate applied by the operation."""
         return self._gate
 
     @property
-    def qubits(self) -> Tuple['cirq.Qid', ...]:
+    def qubits(self) -> tuple[cirq.Qid, ...]:
         """The qubits targeted by the operation."""
         return self._qubits
 
-    def with_qubits(self, *new_qubits: 'cirq.Qid') -> Self:
+    def with_qubits(self, *new_qubits: cirq.Qid) -> Self:
         return cast(Self, self.gate.on(*new_qubits))
 
-    def with_gate(self, new_gate: 'cirq.Gate') -> 'cirq.Operation':
+    def with_gate(self, new_gate: cirq.Gate) -> cirq.Operation:
         if self.gate is new_gate:
             # As GateOperation is immutable, this can return the original.
             return self
@@ -90,7 +78,7 @@ class GateOperation(raw_types.Operation):
             return self
         return new_gate.on(*self.qubits)
 
-    def _with_key_path_(self, path: Tuple[str, ...]):
+    def _with_key_path_(self, path: tuple[str, ...]):
         new_gate = protocols.with_key_path(self.gate, path)
         if new_gate is NotImplemented:
             return NotImplemented
@@ -99,7 +87,7 @@ class GateOperation(raw_types.Operation):
             return self
         return new_gate.on(*self.qubits)
 
-    def _with_key_path_prefix_(self, prefix: Tuple[str, ...]):
+    def _with_key_path_prefix_(self, prefix: tuple[str, ...]):
         new_gate = protocols.with_key_path_prefix(self.gate, prefix)
         if new_gate is NotImplemented:
             return NotImplemented
@@ -109,7 +97,7 @@ class GateOperation(raw_types.Operation):
         return new_gate.on(*self.qubits)
 
     def _with_rescoped_keys_(
-        self, path: Tuple[str, ...], bindable_keys: FrozenSet['cirq.MeasurementKey']
+        self, path: tuple[str, ...], bindable_keys: frozenset[cirq.MeasurementKey]
     ):
         new_gate = protocols.with_rescoped_keys(self.gate, path, bindable_keys)
         if new_gate is self.gate:
@@ -137,15 +125,15 @@ class GateOperation(raw_types.Operation):
         qubits = ', '.join(str(e) for e in self.qubits)
         return f'{self.gate}({qubits})' if qubits else str(self.gate)
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ['gate', 'qubits'])
 
     def _group_interchangeable_qubits(
         self,
-    ) -> Tuple[Union['cirq.Qid', Tuple[int, FrozenSet['cirq.Qid']]], ...]:
+    ) -> tuple[cirq.Qid | tuple[int, frozenset[cirq.Qid]], ...]:
         if not isinstance(self.gate, gate_features.InterchangeableQubitsGate):
             return self.qubits
-        groups: Dict[int, List['cirq.Qid']] = {}
+        groups: dict[int, list[cirq.Qid]] = {}
         for i, q in enumerate(self.qubits):
             k = self.gate.qubit_index_to_equivalence_group_key(i)
             groups.setdefault(k, []).append(q)
@@ -160,12 +148,12 @@ class GateOperation(raw_types.Operation):
     def _num_qubits_(self):
         return len(self._qubits)
 
-    def _decompose_(self) -> 'cirq.OP_TREE':
+    def _decompose_(self) -> cirq.OP_TREE:
         return self._decompose_with_context_()
 
     def _decompose_with_context_(
-        self, context: Optional['cirq.DecompositionContext'] = None
-    ) -> 'cirq.OP_TREE':
+        self, context: cirq.DecompositionContext | None = None
+    ) -> cirq.OP_TREE:
         return protocols.decompose_once_with_qubits(
             self.gate, self.qubits, NotImplemented, flatten=False, context=context
         )
@@ -177,8 +165,8 @@ class GateOperation(raw_types.Operation):
         return NotImplemented
 
     def _apply_unitary_(
-        self, args: 'protocols.ApplyUnitaryArgs'
-    ) -> Union[np.ndarray, None, NotImplementedType]:
+        self, args: protocols.ApplyUnitaryArgs
+    ) -> np.ndarray | None | NotImplementedType:
         getter = getattr(self.gate, '_apply_unitary_', None)
         if getter is not None:
             return getter(args)
@@ -190,15 +178,13 @@ class GateOperation(raw_types.Operation):
             return getter()
         return NotImplemented
 
-    def _unitary_(self) -> Union[np.ndarray, NotImplementedType]:
+    def _unitary_(self) -> np.ndarray | NotImplementedType:
         getter = getattr(self.gate, '_unitary_', None)
         if getter is not None:
             return getter()
         return NotImplemented
 
-    def _commutes_(
-        self, other: Any, *, atol: float = 1e-8
-    ) -> Union[bool, NotImplementedType, None]:
+    def _commutes_(self, other: Any, *, atol: float = 1e-8) -> bool | NotImplementedType | None:
         commutes = self.gate._commutes_on_qids_(self.qubits, other, atol=atol)
         if commutes is not NotImplemented:
             return commutes
@@ -211,15 +197,15 @@ class GateOperation(raw_types.Operation):
             return getter()
         return NotImplemented
 
-    def _mixture_(self) -> Sequence[Tuple[float, Any]]:
+    def _mixture_(self) -> Sequence[tuple[float, Any]]:
         getter = getattr(self.gate, '_mixture_', None)
         if getter is not None:
             return getter()
         return NotImplemented
 
     def _apply_channel_(
-        self, args: 'protocols.ApplyChannelArgs'
-    ) -> Union[np.ndarray, None, NotImplementedType]:
+        self, args: protocols.ApplyChannelArgs
+    ) -> np.ndarray | None | NotImplementedType:
         getter = getattr(self.gate, '_apply_channel_', None)
         if getter is not None:
             return getter(args)
@@ -231,46 +217,44 @@ class GateOperation(raw_types.Operation):
             return getter()
         return NotImplemented
 
-    def _kraus_(self) -> Union[Tuple[np.ndarray], NotImplementedType]:
+    def _kraus_(self) -> tuple[np.ndarray] | NotImplementedType:
         getter = getattr(self.gate, '_kraus_', None)
         if getter is not None:
             return getter()
         return NotImplemented
 
-    def _is_measurement_(self) -> Optional[bool]:
+    def _is_measurement_(self) -> bool | None:
         getter = getattr(self.gate, '_is_measurement_', None)
         if getter is not None:
             return getter()
         # Let the protocol handle the fallback.
         return NotImplemented
 
-    def _measurement_key_name_(self) -> Optional[str]:
+    def _measurement_key_name_(self) -> str | None:
         getter = getattr(self.gate, '_measurement_key_name_', None)
         if getter is not None:
             return getter()
         return NotImplemented
 
-    def _measurement_key_names_(self) -> Union[FrozenSet[str], NotImplementedType, None]:
+    def _measurement_key_names_(self) -> frozenset[str] | NotImplementedType | None:
         getter = getattr(self.gate, '_measurement_key_names_', None)
         if getter is not None:
             return getter()
         return NotImplemented
 
-    def _measurement_key_obj_(self) -> Optional['cirq.MeasurementKey']:
+    def _measurement_key_obj_(self) -> cirq.MeasurementKey | None:
         getter = getattr(self.gate, '_measurement_key_obj_', None)
         if getter is not None:
             return getter()
         return NotImplemented
 
-    def _measurement_key_objs_(
-        self,
-    ) -> Union[FrozenSet['cirq.MeasurementKey'], NotImplementedType, None]:
+    def _measurement_key_objs_(self) -> frozenset[cirq.MeasurementKey] | NotImplementedType | None:
         getter = getattr(self.gate, '_measurement_key_objs_', None)
         if getter is not None:
             return getter()
         return NotImplemented
 
-    def _act_on_(self, sim_state: 'cirq.SimulationStateBase'):
+    def _act_on_(self, sim_state: cirq.SimulationStateBase):
         getter = getattr(self.gate, '_act_on_', None)
         if getter is not None:
             return getter(sim_state, self.qubits)
@@ -288,15 +272,11 @@ class GateOperation(raw_types.Operation):
             return getter()
         return NotImplemented
 
-    def _resolve_parameters_(
-        self, resolver: 'cirq.ParamResolver', recursive: bool
-    ) -> 'cirq.Operation':
+    def _resolve_parameters_(self, resolver: cirq.ParamResolver, recursive: bool) -> cirq.Operation:
         resolved_gate = protocols.resolve_parameters(self.gate, resolver, recursive)
         return self.with_gate(resolved_gate)
 
-    def _circuit_diagram_info_(
-        self, args: 'cirq.CircuitDiagramInfoArgs'
-    ) -> 'cirq.CircuitDiagramInfo':
+    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> cirq.CircuitDiagramInfo:
         return protocols.circuit_diagram_info(self.gate, args, NotImplemented)
 
     def _decompose_into_clifford_(self):
@@ -311,13 +291,13 @@ class GateOperation(raw_types.Operation):
             return getter()
         return NotImplemented
 
-    def _phase_by_(self, phase_turns: float, qubit_index: int) -> 'GateOperation':
+    def _phase_by_(self, phase_turns: float, qubit_index: int) -> GateOperation:
         phased_gate = protocols.phase_by(self.gate, phase_turns, qubit_index, default=None)
         if phased_gate is None:
             return NotImplemented
         return GateOperation(phased_gate, self._qubits)
 
-    def __pow__(self, exponent: Any) -> 'cirq.Operation':
+    def __pow__(self, exponent: Any) -> cirq.Operation:
         """Raise gate to a power, then reapply to the same qubits.
 
         Only works if the gate implements cirq.ExtrapolatableEffect.
@@ -348,7 +328,7 @@ class GateOperation(raw_types.Operation):
     def __rmul__(self, other: Any) -> Any:
         return self.gate._rmul_with_qubits(self._qubits, other)
 
-    def _qasm_(self, args: 'protocols.QasmArgs') -> Optional[str]:
+    def _qasm_(self, args: protocols.QasmArgs) -> str | None:
         if isinstance(self.gate, ops.GlobalPhaseGate):
             warnings.warn(
                 "OpenQASM 2.0 does not support global phase."
@@ -361,7 +341,7 @@ class GateOperation(raw_types.Operation):
 
     def _equal_up_to_global_phase_(
         self, other: Any, atol: float = 1e-8
-    ) -> Union[NotImplementedType, bool]:
+    ) -> NotImplementedType | bool:
         if not isinstance(other, type(self)):
             return NotImplemented
         if self._group_interchangeable_qubits() != other._group_interchangeable_qubits():
@@ -370,11 +350,9 @@ class GateOperation(raw_types.Operation):
 
     def controlled_by(
         self,
-        *control_qubits: 'cirq.Qid',
-        control_values: Optional[
-            Union[cv.AbstractControlValues, Sequence[Union[int, Collection[int]]]]
-        ] = None,
-    ) -> 'cirq.Operation':
+        *control_qubits: cirq.Qid,
+        control_values: cv.AbstractControlValues | Sequence[int | Collection[int]] | None = None,
+    ) -> cirq.Operation:
         if len(control_qubits) == 0:
             return self
         qubits = tuple(control_qubits)

cirq/ops/gate_operation_test.py

@@ -11,8 +11,12 @@
 # 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 collections.abc
 import pathlib
+from typing import cast
 
 import numpy as np
 import pytest
@@ -22,7 +26,7 @@ import cirq
 import cirq.testing
 
 
-def test_gate_operation_init():
+def test_gate_operation_init() -> None:
     q = cirq.NamedQubit('q')
     g = cirq.testing.SingleQubitGate()
     v = cirq.GateOperation(g, (q,))
@@ -30,14 +34,14 @@ def test_gate_operation_init():
     assert v.qubits == (q,)
 
 
-def test_invalid_gate_operation():
+def test_invalid_gate_operation() -> None:
     three_qubit_gate = cirq.testing.ThreeQubitGate()
     single_qubit = [cirq.GridQubit(0, 0)]
     with pytest.raises(ValueError, match="number of qubits"):
         cirq.GateOperation(three_qubit_gate, single_qubit)
 
 
-def test_immutable():
+def test_immutable() -> None:
     a, b = cirq.LineQubit.range(2)
     op = cirq.X(a)
 
@@ -57,7 +61,7 @@ def test_immutable():
         op.qubits = [b]
 
 
-def test_gate_operation_eq():
+def test_gate_operation_eq() -> None:
     g1 = cirq.testing.SingleQubitGate()
     g2 = cirq.testing.SingleQubitGate()
     g3 = cirq.testing.TwoQubitGate()
@@ -102,7 +106,7 @@ def test_gate_operation_eq():
     eq.add_equality_group(p(b0, a1, a0, b1, c0))
 
 
-def test_gate_operation_approx_eq():
+def test_gate_operation_approx_eq() -> None:
     a = [cirq.NamedQubit('r1')]
     b = [cirq.NamedQubit('r2')]
 
@@ -128,7 +132,7 @@ def test_gate_operation_approx_eq():
     )
 
 
-def test_gate_operation_qid_shape():
+def test_gate_operation_qid_shape() -> None:
     class ShapeGate(cirq.Gate):
         def _qid_shape_(self):
             return (1, 2, 3, 4)
@@ -138,7 +142,7 @@ def test_gate_operation_qid_shape():
     assert cirq.num_qubits(op) == 4
 
 
-def test_gate_operation_num_qubits():
+def test_gate_operation_num_qubits() -> None:
     class NumQubitsGate(cirq.Gate):
         def _num_qubits_(self):
             return 4
@@ -148,25 +152,25 @@ def test_gate_operation_num_qubits():
     assert cirq.num_qubits(op) == 4
 
 
-def test_gate_operation_pow():
+def test_gate_operation_pow() -> None:
     Y = cirq.Y
     q = cirq.NamedQubit('q')
     assert (Y**0.5)(q) == Y(q) ** 0.5
 
 
-def test_with_qubits_and_transform_qubits():
+def test_with_qubits_and_transform_qubits() -> None:
     g = cirq.testing.ThreeQubitGate()
     g = cirq.testing.ThreeQubitGate()
     op = cirq.GateOperation(g, cirq.LineQubit.range(3))
     assert op.with_qubits(*cirq.LineQubit.range(3, 0, -1)) == cirq.GateOperation(
         g, cirq.LineQubit.range(3, 0, -1)
     )
-    assert op.transform_qubits(lambda e: cirq.LineQubit(-e.x)) == cirq.GateOperation(
-        g, [cirq.LineQubit(0), cirq.LineQubit(-1), cirq.LineQubit(-2)]
-    )
+    assert op.transform_qubits(
+        lambda e: cirq.LineQubit(-cast(cirq.LineQubit, e).x)
+    ) == cirq.GateOperation(g, [cirq.LineQubit(0), cirq.LineQubit(-1), cirq.LineQubit(-2)])
 
 
-def test_extrapolate():
+def test_extrapolate() -> None:
     q = cirq.NamedQubit('q')
 
     # If the gate isn't extrapolatable, you get a type error.
@@ -179,7 +183,7 @@ def test_extrapolate():
     assert (cirq.Y**0.5).on(q) == cirq.Y(q) ** 0.5
 
 
-def test_inverse():
+def test_inverse() -> None:
     q = cirq.NamedQubit('q')
 
     # If the gate isn't reversible, you get a type error.
@@ -191,7 +195,7 @@ def test_inverse():
     assert cirq.inverse(cirq.S).on(q) == cirq.inverse(cirq.S.on(q))
 
 
-def test_text_diagrammable():
+def test_text_diagrammable() -> None:
     q = cirq.NamedQubit('q')
 
     # If the gate isn't diagrammable, you get a type error.
@@ -205,7 +209,7 @@ def test_text_diagrammable():
     assert actual == expected
 
 
-def test_bounded_effect():
+def test_bounded_effect() -> None:
     q = cirq.NamedQubit('q')
 
     # If the gate isn't bounded, you get a type error.
@@ -217,7 +221,7 @@ def test_bounded_effect():
 
 
 @pytest.mark.parametrize('resolve_fn', [cirq.resolve_parameters, cirq.resolve_parameters_once])
-def test_parameterizable_effect(resolve_fn):
+def test_parameterizable_effect(resolve_fn) -> None:
     q = cirq.NamedQubit('q')
     r = cirq.ParamResolver({'a': 0.5})
 
@@ -228,7 +232,7 @@ def test_parameterizable_effect(resolve_fn):
     assert op2 == cirq.S.on(q)
 
 
-def test_pauli_expansion():
+def test_pauli_expansion() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
 
@@ -250,7 +254,7 @@ def test_pauli_expansion():
     assert cirq.pauli_expansion(Yes().on(a)) == cirq.LinearDict({'X': 0.5})
 
 
-def test_unitary():
+def test_unitary() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
 
@@ -260,7 +264,7 @@ def test_unitary():
     np.testing.assert_allclose(cirq.unitary(cirq.CNOT(a, b)), cirq.unitary(cirq.CNOT), atol=1e-8)
 
 
-def test_channel():
+def test_channel() -> None:
     a = cirq.NamedQubit('a')
     op = cirq.bit_flip(0.5).on(a)
     np.testing.assert_allclose(cirq.kraus(op), cirq.kraus(op.gate))
@@ -270,19 +274,19 @@ def test_channel():
     assert not cirq.has_kraus(cirq.testing.SingleQubitGate()(a))
 
 
-def test_measurement_key():
+def test_measurement_key() -> None:
     a = cirq.NamedQubit('a')
     assert cirq.measurement_key_name(cirq.measure(a, key='lock')) == 'lock'
 
 
-def assert_mixtures_equal(actual, expected):
+def assert_mixtures_equal(actual, expected) -> None:
     """Assert equal for tuple of mixed scalar and array types."""
     for a, e in zip(actual, expected):
         np.testing.assert_almost_equal(a[0], e[0])
         np.testing.assert_almost_equal(a[1], e[1])
 
 
-def test_mixture():
+def test_mixture() -> None:
     a = cirq.NamedQubit('a')
     op = cirq.bit_flip(0.5).on(a)
     assert_mixtures_equal(cirq.mixture(op), cirq.mixture(op.gate))
@@ -295,7 +299,7 @@ def test_mixture():
     np.testing.assert_allclose(m[0][1], cirq.unitary(cirq.X))
 
 
-def test_repr():
+def test_repr() -> None:
     a, b = cirq.LineQubit.range(2)
     assert (
         repr(cirq.GateOperation(cirq.CZ, (a, b))) == 'cirq.CZ(cirq.LineQubit(0), cirq.LineQubit(1))'
@@ -324,7 +328,7 @@ def test_repr():
         (cirq.Z ** sympy.Symbol('e'), cirq.Z ** sympy.Symbol('f'), False),
     ],
 )
-def test_equal_up_to_global_phase_on_gates(gate1, gate2, eq_up_to_global_phase):
+def test_equal_up_to_global_phase_on_gates(gate1, gate2, eq_up_to_global_phase) -> None:
     num_qubits1, num_qubits2 = (cirq.num_qubits(g) for g in (gate1, gate2))
     qubits = cirq.LineQubit.range(max(num_qubits1, num_qubits2) + 1)
     op1, op2 = gate1(*qubits[:num_qubits1]), gate2(*qubits[:num_qubits2])
@@ -333,12 +337,12 @@ def test_equal_up_to_global_phase_on_gates(gate1, gate2, eq_up_to_global_phase):
     assert not cirq.equal_up_to_global_phase(op1, op2_on_diff_qubits)
 
 
-def test_equal_up_to_global_phase_on_diff_types():
+def test_equal_up_to_global_phase_on_diff_types() -> None:
     op = cirq.X(cirq.LineQubit(0))
     assert not cirq.equal_up_to_global_phase(op, 3)
 
 
-def test_gate_on_operation_besides_gate_operation():
+def test_gate_on_operation_besides_gate_operation() -> None:
     a, b = cirq.LineQubit.range(2)
 
     op = -1j * cirq.X(a) * cirq.Y(b)
@@ -347,7 +351,7 @@ def test_gate_on_operation_besides_gate_operation():
     assert not isinstance(op.gate, cirq.XPowGate)
 
 
-def test_mul():
+def test_mul() -> None:
     class GateRMul(cirq.Gate):
         def num_qubits(self) -> int:
             return 1
@@ -373,29 +377,29 @@ def test_mul():
     # Delegates right multiplication.
     q = cirq.LineQubit(0)
     r = GateRMul().on(q)
-    assert 2 * r == 3
+    assert 2 * r == 3  # type: ignore[operator]
     with pytest.raises(TypeError):
-        _ = r * 2
+        _ = r * 2  # type: ignore[operator]
 
     # Delegates left multiplication.
     m = GateMul().on(q)
-    assert m * 2 == 5
+    assert m * 2 == 5  # type: ignore[operator]
     with pytest.raises(TypeError):
-        _ = 2 * m
+        _ = 2 * m  # type: ignore[operator]
 
     # Handles the symmetric type case correctly.
-    assert m * m == 6
-    assert r * r == 4
+    assert m * m == 6  # type: ignore[operator]
+    assert r * r == 4  # type: ignore[operator]
 
 
-def test_with_gate():
+def test_with_gate() -> None:
     g1 = cirq.GateOperation(cirq.X, cirq.LineQubit.range(1))
     g2 = cirq.GateOperation(cirq.Y, cirq.LineQubit.range(1))
     assert g1.with_gate(cirq.X) is g1
     assert g1.with_gate(cirq.Y) == g2
 
 
-def test_with_measurement_key_mapping():
+def test_with_measurement_key_mapping() -> None:
     a = cirq.LineQubit(0)
     op = cirq.measure(a, key='m')
 
@@ -404,7 +408,7 @@ def test_with_measurement_key_mapping():
     assert cirq.with_measurement_key_mapping(op, {'x': 'k'}) is op
 
 
-def test_with_key_path():
+def test_with_key_path() -> None:
     a = cirq.LineQubit(0)
     op = cirq.measure(a, key='m')
 
@@ -417,7 +421,7 @@ def test_with_key_path():
     assert cirq.with_key_path(cirq.X(a), ('a', 'b')) is NotImplemented
 
 
-def test_with_key_path_prefix():
+def test_with_key_path_prefix() -> None:
     a = cirq.LineQubit(0)
     op = cirq.measure(a, key='m')
     remap_op = cirq.with_key_path_prefix(op, ('a', 'b'))
@@ -427,14 +431,14 @@ def test_with_key_path_prefix():
     assert cirq.with_key_path_prefix(cirq.X(a), ('a', 'b')) is NotImplemented
 
 
-def test_cannot_remap_non_measurement_gate():
+def test_cannot_remap_non_measurement_gate() -> None:
     a = cirq.LineQubit(0)
     op = cirq.X(a)
 
     assert cirq.with_measurement_key_mapping(op, {'m': 'k'}) is NotImplemented
 
 
-def test_is_parameterized():
+def test_is_parameterized() -> None:
     class No1(cirq.testing.SingleQubitGate):
         def num_qubits(self) -> int:
             return 1
@@ -460,7 +464,7 @@ def test_is_parameterized():
     assert cirq.is_parameterized(Yes().on(q))
 
 
-def test_group_interchangeable_qubits_creates_tuples_with_unique_keys():
+def test_group_interchangeable_qubits_creates_tuples_with_unique_keys() -> None:
     class MyGate(cirq.Gate, cirq.InterchangeableQubitsGate):
         def __init__(self, num_qubits) -> None:
             self._num_qubits = num_qubits
@@ -481,7 +485,7 @@ def test_group_interchangeable_qubits_creates_tuples_with_unique_keys():
     )
 
 
-def test_gate_to_operation_to_gate_round_trips():
+def test_gate_to_operation_to_gate_round_trips() -> None:
     def all_subclasses(cls):
         return set(cls.__subclasses__()).union(
             [s for c in cls.__subclasses__() for s in all_subclasses(c)]