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

cirq/ops/swap_gates_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
 import sympy
@@ -21,11 +23,11 @@ import cirq
 
 
 @pytest.mark.parametrize('eigen_gate_type', [cirq.ISwapPowGate, cirq.SwapPowGate])
-def test_phase_sensitive_eigen_gates_consistent_protocols(eigen_gate_type):
+def test_phase_sensitive_eigen_gates_consistent_protocols(eigen_gate_type) -> None:
     cirq.testing.assert_eigengate_implements_consistent_protocols(eigen_gate_type)
 
 
-def test_interchangeable_qubit_eq():
+def test_interchangeable_qubit_eq() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
     c = cirq.NamedQubit('c')
@@ -44,7 +46,7 @@ def test_interchangeable_qubit_eq():
     eq.add_equality_group(cirq.ISWAP(a, c) ** 0.3)
 
 
-def test_text_diagrams():
+def test_text_diagrams() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
     circuit = cirq.Circuit(cirq.SWAP(a, b), cirq.ISWAP(a, b) ** -1)
@@ -69,14 +71,14 @@ b: ---Swap---iSwap^-1---
     )
 
 
-def test_swap_has_stabilizer_effect():
+def test_swap_has_stabilizer_effect() -> None:
     assert cirq.has_stabilizer_effect(cirq.SWAP)
     assert cirq.has_stabilizer_effect(cirq.SWAP**2)
     assert not cirq.has_stabilizer_effect(cirq.SWAP**0.5)
     assert not cirq.has_stabilizer_effect(cirq.SWAP ** sympy.Symbol('foo'))
 
 
-def test_swap_unitary():
+def test_swap_unitary() -> None:
     # yapf: disable
     np.testing.assert_almost_equal(
         cirq.unitary(cirq.SWAP**0.5),
@@ -89,7 +91,7 @@ def test_swap_unitary():
     # yapf: enable
 
 
-def test_iswap_unitary():
+def test_iswap_unitary() -> None:
     # yapf: disable
     cirq.testing.assert_allclose_up_to_global_phase(
         cirq.unitary(cirq.ISWAP),
@@ -103,7 +105,7 @@ def test_iswap_unitary():
     # yapf: enable
 
 
-def test_iswap_inv_unitary():
+def test_iswap_inv_unitary() -> None:
     # yapf: disable
     cirq.testing.assert_allclose_up_to_global_phase(
         cirq.unitary(cirq.ISWAP_INV),
@@ -117,7 +119,7 @@ def test_iswap_inv_unitary():
     # yapf: enable
 
 
-def test_sqrt_iswap_unitary():
+def test_sqrt_iswap_unitary() -> None:
     # yapf: disable
     cirq.testing.assert_allclose_up_to_global_phase(
         cirq.unitary(cirq.SQRT_ISWAP),
@@ -131,7 +133,7 @@ def test_sqrt_iswap_unitary():
     # yapf: enable
 
 
-def test_sqrt_iswap_inv_unitary():
+def test_sqrt_iswap_inv_unitary() -> None:
     # yapf: disable
     cirq.testing.assert_allclose_up_to_global_phase(
         cirq.unitary(cirq.SQRT_ISWAP_INV),
@@ -145,7 +147,7 @@ def test_sqrt_iswap_inv_unitary():
     # yapf: enable
 
 
-def test_repr():
+def test_repr() -> None:
     assert repr(cirq.SWAP) == 'cirq.SWAP'
     assert repr(cirq.SWAP**0.5) == '(cirq.SWAP**0.5)'
 
@@ -156,7 +158,7 @@ def test_repr():
     assert repr(cirq.ISWAP_INV**0.5) == '(cirq.ISWAP**-0.5)'
 
 
-def test_str():
+def test_str() -> None:
     assert str(cirq.SWAP) == 'SWAP'
     assert str(cirq.SWAP**0.5) == 'SWAP**0.5'
 
@@ -167,7 +169,7 @@ def test_str():
     assert str(cirq.ISWAP_INV**0.5) == 'ISWAP**-0.5'
 
 
-def test_iswap_decompose_diagram():
+def test_iswap_decompose_diagram() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
 
@@ -182,7 +184,7 @@ b: ───X───────@───────@───────
     )
 
 
-def test_trace_distance():
+def test_trace_distance() -> None:
     foo = sympy.Symbol('foo')
     sswap = cirq.SWAP**foo
     siswap = cirq.ISWAP**foo
@@ -194,14 +196,14 @@ def test_trace_distance():
     assert cirq.approx_eq(cirq.trace_distance_bound(cirq.ISWAP**0), 0.0)
 
 
-def test_trace_distance_over_range_of_exponents():
+def test_trace_distance_over_range_of_exponents() -> None:
     for exp in np.linspace(0, 4, 20):
         cirq.testing.assert_has_consistent_trace_distance_bound(cirq.SWAP**exp)
         cirq.testing.assert_has_consistent_trace_distance_bound(cirq.ISWAP**exp)
 
 
 @pytest.mark.parametrize('angle_rads', (-np.pi, -np.pi / 3, -0.1, np.pi / 5))
-def test_riswap_unitary(angle_rads):
+def test_riswap_unitary(angle_rads) -> None:
     actual = cirq.unitary(cirq.riswap(angle_rads))
     c = np.cos(angle_rads)
     s = 1j * np.sin(angle_rads)
@@ -215,7 +217,7 @@ def test_riswap_unitary(angle_rads):
 
 
 @pytest.mark.parametrize('angle_rads', (-2 * np.pi / 3, -0.2, 0.4, np.pi / 4))
-def test_riswap_hamiltonian(angle_rads):
+def test_riswap_hamiltonian(angle_rads) -> None:
     actual = cirq.unitary(cirq.riswap(angle_rads))
     x = np.array([[0, 1], [1, 0]])
     y = np.array([[0, -1j], [1j, 0]])
@@ -226,5 +228,5 @@ def test_riswap_hamiltonian(angle_rads):
 
 
 @pytest.mark.parametrize('angle_rads', (-np.pi / 5, 0.4, 2, np.pi))
-def test_riswap_has_consistent_protocols(angle_rads):
+def test_riswap_has_consistent_protocols(angle_rads) -> None:
     cirq.testing.assert_implements_consistent_protocols(cirq.riswap(angle_rads))

cirq/ops/tags.py

@@ -11,8 +11,10 @@
 # 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.
+
 """Canonical tags for the TaggedOperation class."""
-from typing import Dict
+
+from __future__ import annotations
 
 
 class VirtualTag:
@@ -38,7 +40,7 @@ class VirtualTag:
     def __repr__(self) -> str:
         return 'cirq.VirtualTag()'
 
-    def _json_dict_(self) -> Dict[str, str]:
+    def _json_dict_(self) -> dict[str, str]:
         return {}
 
     def __hash__(self):
@@ -61,7 +63,7 @@ class RoutingSwapTag:
     def __repr__(self) -> str:
         return 'cirq.RoutingSwapTag()'
 
-    def _json_dict_(self) -> Dict[str, str]:
+    def _json_dict_(self) -> dict[str, str]:
         return {}
 
     def __hash__(self):

cirq/ops/tags_test.py

@@ -12,10 +12,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import cirq
 
 
-def test_virtual_tag():
+def test_virtual_tag() -> None:
     tag1 = cirq.ops.VirtualTag()
     tag2 = cirq.ops.VirtualTag()
 
@@ -26,7 +28,7 @@ def test_virtual_tag():
     cirq.testing.assert_equivalent_repr(tag2)
 
 
-def test_routing_swap_tag():
+def test_routing_swap_tag() -> None:
     tag1 = cirq.ops.RoutingSwapTag()
     tag2 = cirq.ops.RoutingSwapTag()
 

cirq/ops/three_qubit_gates.py

@@ -14,19 +14,9 @@
 
 """Common quantum gates that target three qubits."""
 
-from typing import (
-    AbstractSet,
-    Any,
-    Collection,
-    Dict,
-    Iterator,
-    List,
-    Optional,
-    Sequence,
-    Tuple,
-    TYPE_CHECKING,
-    Union,
-)
+from __future__ import annotations
+
+from typing import AbstractSet, Any, Collection, Iterator, Sequence, TYPE_CHECKING
 
 import numpy as np
 import sympy
@@ -47,7 +37,6 @@ from cirq.ops import (
 )
 
 if TYPE_CHECKING:
-    # pylint: disable=unused-import
     import cirq
 
 
@@ -70,10 +59,10 @@ class CCZPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate):
     $$
     """
 
-    def _eigen_components(self) -> List[Tuple[float, np.ndarray]]:
+    def _eigen_components(self) -> list[tuple[float, np.ndarray]]:
         return [(0, np.diag([1, 1, 1, 1, 1, 1, 1, 0])), (1, np.diag([0, 0, 0, 0, 0, 0, 0, 1]))]
 
-    def _trace_distance_bound_(self) -> Optional[float]:
+    def _trace_distance_bound_(self) -> float | None:
         if self._is_parameterized_():
             return None
         return abs(np.sin(self._exponent * 0.5 * np.pi))
@@ -117,19 +106,11 @@ class CCZPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate):
             elif not b.is_adjacent(c):
                 a, b = b, a
 
-        p = common_gates.T**self._exponent
+        exp = self._exponent
+        p = common_gates.T**exp
         sweep_abc = [common_gates.CNOT(a, b), common_gates.CNOT(b, c)]
-        global_phase = 1j ** (2 * self.global_shift * self._exponent)
-        global_phase = (
-            complex(global_phase)
-            if protocols.is_parameterized(global_phase) and global_phase.is_complex
-            else global_phase
-        )
-        global_phase_operation = (
-            [global_phase_op.global_phase_operation(global_phase)]
-            if protocols.is_parameterized(global_phase) or abs(global_phase - 1.0) > 0
-            else []
-        )
+        global_phase_gate = global_phase_op.from_phase_and_exponent(self.global_shift, exp)
+        global_phase_operation = [] if global_phase_gate.is_identity() else [global_phase_gate()]
         return global_phase_operation + [
             p(a),
             p(b),
@@ -144,7 +125,7 @@ class CCZPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate):
             sweep_abc,
         ]
 
-    def _apply_unitary_(self, args: 'protocols.ApplyUnitaryArgs') -> np.ndarray:
+    def _apply_unitary_(self, args: protocols.ApplyUnitaryArgs) -> np.ndarray:
         if protocols.is_parameterized(self):
             return NotImplemented
         ooo = args.subspace_index(0b111)
@@ -154,12 +135,10 @@ class CCZPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate):
             args.target_tensor *= p
         return args.target_tensor
 
-    def _circuit_diagram_info_(
-        self, args: 'cirq.CircuitDiagramInfoArgs'
-    ) -> 'cirq.CircuitDiagramInfo':
+    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> cirq.CircuitDiagramInfo:
         return protocols.CircuitDiagramInfo(('@', '@', '@'), exponent=self._diagram_exponent(args))
 
-    def _qasm_(self, args: 'cirq.QasmArgs', qubits: Tuple['cirq.Qid', ...]) -> Optional[str]:
+    def _qasm_(self, args: cirq.QasmArgs, qubits: tuple[cirq.Qid, ...]) -> str | None:
         if self._exponent != 1:
             return None
 
@@ -191,11 +170,9 @@ class CCZPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate):
 
     def controlled(
         self,
-        num_controls: Optional[int] = None,
-        control_values: Optional[
-            Union[cv.AbstractControlValues, Sequence[Union[int, Collection[int]]]]
-        ] = None,
-        control_qid_shape: Optional[Tuple[int, ...]] = None,
+        num_controls: int | None = None,
+        control_values: cv.AbstractControlValues | Sequence[int | Collection[int]] | None = None,
+        control_qid_shape: tuple[int, ...] | None = None,
     ) -> raw_types.Gate:
         """Returns a controlled `ZPowGate` with two additional controls.
 
@@ -206,7 +183,7 @@ class CCZPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate):
         """
         if num_controls == 0:
             return self
-        sub_gate: 'cirq.Gate' = self
+        sub_gate: cirq.Gate = self
         if self._global_shift == 0:
             sub_gate = controlled_gate.ControlledGate(
                 common_gates.ZPowGate(exponent=self._exponent), num_controls=2
@@ -238,10 +215,10 @@ class ThreeQubitDiagonalGate(raw_types.Gate):
                 If these values are $(x_0, x_1, \ldots , x_7)$ then the unitary
                 has diagonal values $(e^{i x_0}, e^{i x_1}, \ldots, e^{i x_7})$.
         """
-        self._diag_angles_radians: Tuple[value.TParamVal, ...] = tuple(diag_angles_radians)
+        self._diag_angles_radians: tuple[value.TParamVal, ...] = tuple(diag_angles_radians)
 
     @property
-    def diag_angles_radians(self) -> Tuple[value.TParamVal, ...]:
+    def diag_angles_radians(self) -> tuple[value.TParamVal, ...]:
         return self._diag_angles_radians
 
     def _is_parameterized_(self) -> bool:
@@ -253,8 +230,8 @@ class ThreeQubitDiagonalGate(raw_types.Gate):
         }
 
     def _resolve_parameters_(
-        self, resolver: 'cirq.ParamResolver', recursive: bool
-    ) -> 'ThreeQubitDiagonalGate':
+        self, resolver: cirq.ParamResolver, recursive: bool
+    ) -> ThreeQubitDiagonalGate:
         return self.__class__(
             [
                 protocols.resolve_parameters(angle, resolver, recursive)
@@ -270,7 +247,7 @@ class ThreeQubitDiagonalGate(raw_types.Gate):
             return NotImplemented
         return np.diag([np.exp(1j * angle) for angle in self._diag_angles_radians])
 
-    def _apply_unitary_(self, args: 'protocols.ApplyUnitaryArgs') -> np.ndarray:
+    def _apply_unitary_(self, args: protocols.ApplyUnitaryArgs) -> np.ndarray:
         if self._is_parameterized_():
             return NotImplemented
         for index, angle in enumerate(self._diag_angles_radians):
@@ -279,16 +256,14 @@ class ThreeQubitDiagonalGate(raw_types.Gate):
             args.target_tensor[subspace_index] *= np.exp(1j * angle)
         return args.target_tensor
 
-    def _circuit_diagram_info_(
-        self, args: 'cirq.CircuitDiagramInfoArgs'
-    ) -> 'cirq.CircuitDiagramInfo':
+    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> cirq.CircuitDiagramInfo:
         rounded_angles = np.array(self._diag_angles_radians)
         if args.precision is not None:
             rounded_angles = rounded_angles.round(args.precision)
         diag_str = f"diag({', '.join(proper_repr(angle) for angle in rounded_angles)})"
         return protocols.CircuitDiagramInfo((diag_str, '#2', '#3'))
 
-    def __pow__(self, exponent: Any) -> 'ThreeQubitDiagonalGate':
+    def __pow__(self, exponent: Any) -> ThreeQubitDiagonalGate:
         if not isinstance(exponent, (int, float, sympy.Basic)):
             return NotImplemented
         return ThreeQubitDiagonalGate(
@@ -382,7 +357,7 @@ class ThreeQubitDiagonalGate(raw_types.Gate):
             }
         )
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(self, attribute_names=["diag_angles_radians"])
 
     def __repr__(self) -> str:
@@ -413,7 +388,7 @@ class CCXPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate):
     $$
     """
 
-    def _eigen_components(self) -> List[Tuple[float, np.ndarray]]:
+    def _eigen_components(self) -> list[tuple[float, np.ndarray]]:
         return [
             (0, linalg.block_diag(np.diag([1, 1, 1, 1, 1, 1]), np.array([[0.5, 0.5], [0.5, 0.5]]))),
             (
@@ -424,7 +399,7 @@ class CCXPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate):
             ),
         ]
 
-    def _trace_distance_bound_(self) -> Optional[float]:
+    def _trace_distance_bound_(self) -> float | None:
         if self._is_parameterized_():
             return None
         return abs(np.sin(self._exponent * 0.5 * np.pi))
@@ -451,7 +426,7 @@ class CCXPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate):
     def qubit_index_to_equivalence_group_key(self, index):
         return index < 2
 
-    def _apply_unitary_(self, args: 'protocols.ApplyUnitaryArgs') -> np.ndarray:
+    def _apply_unitary_(self, args: protocols.ApplyUnitaryArgs) -> np.ndarray:
         if protocols.is_parameterized(self):
             return NotImplemented
         p = 1j ** (2 * self._exponent * self._global_shift)
@@ -471,14 +446,12 @@ class CCXPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate):
         yield CCZPowGate(exponent=self._exponent, global_shift=self.global_shift).on(c1, c2, t)
         yield common_gates.H(t)
 
-    def _circuit_diagram_info_(
-        self, args: 'cirq.CircuitDiagramInfoArgs'
-    ) -> 'cirq.CircuitDiagramInfo':
+    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> cirq.CircuitDiagramInfo:
         return protocols.CircuitDiagramInfo(
             ('@', '@', 'X'), exponent=self._diagram_exponent(args), exponent_qubit_index=2
         )
 
-    def _qasm_(self, args: 'cirq.QasmArgs', qubits: Tuple['cirq.Qid', ...]) -> Optional[str]:
+    def _qasm_(self, args: cirq.QasmArgs, qubits: tuple[cirq.Qid, ...]) -> str | None:
         if self._exponent != 1:
             return None
 
@@ -505,11 +478,9 @@ class CCXPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate):
 
     def controlled(
         self,
-        num_controls: Optional[int] = None,
-        control_values: Optional[
-            Union[cv.AbstractControlValues, Sequence[Union[int, Collection[int]]]]
-        ] = None,
-        control_qid_shape: Optional[Tuple[int, ...]] = None,
+        num_controls: int | None = None,
+        control_values: cv.AbstractControlValues | Sequence[int | Collection[int]] | None = None,
+        control_qid_shape: tuple[int, ...] | None = None,
     ) -> raw_types.Gate:
         """Returns a controlled `XPowGate` with two additional controls.
 
@@ -520,7 +491,7 @@ class CCXPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate):
         """
         if num_controls == 0:
             return self
-        sub_gate: 'cirq.Gate' = self
+        sub_gate: cirq.Gate = self
         if self._global_shift == 0:
             sub_gate = controlled_gate.ControlledGate(
                 common_gates.XPowGate(exponent=self._exponent), num_controls=2
@@ -572,8 +543,8 @@ class CSwapGate(gate_features.InterchangeableQubitsGate, raw_types.Gate):
         return self._decompose_outside_control(c, t1, t2)
 
     def _decompose_inside_control(
-        self, target1: 'cirq.Qid', control: 'cirq.Qid', target2: 'cirq.Qid'
-    ) -> Iterator['cirq.OP_TREE']:
+        self, target1: cirq.Qid, control: cirq.Qid, target2: cirq.Qid
+    ) -> Iterator[cirq.OP_TREE]:
         """A decomposition assuming the control separates the targets.
 
         target1: ─@─X───────T──────@────────@─────────X───@─────X^-0.5─
@@ -608,7 +579,7 @@ class CSwapGate(gate_features.InterchangeableQubitsGate, raw_types.Gate):
         yield common_gates.S(c) ** -1
         yield pauli_gates.X(a) ** -0.5
 
-    def _apply_unitary_(self, args: 'protocols.ApplyUnitaryArgs') -> np.ndarray:
+    def _apply_unitary_(self, args: protocols.ApplyUnitaryArgs) -> np.ndarray:
         return protocols.apply_unitary(
             controlled_gate.ControlledGate(swap_gates.SWAP),
             protocols.ApplyUnitaryArgs(args.target_tensor, args.available_buffer, args.axes),
@@ -616,8 +587,8 @@ class CSwapGate(gate_features.InterchangeableQubitsGate, raw_types.Gate):
         )
 
     def _decompose_outside_control(
-        self, control: 'cirq.Qid', near_target: 'cirq.Qid', far_target: 'cirq.Qid'
-    ) -> Iterator['cirq.OP_TREE']:
+        self, control: cirq.Qid, near_target: cirq.Qid, far_target: cirq.Qid
+    ) -> Iterator[cirq.OP_TREE]:
         """A decomposition assuming one of the targets is in the middle.
 
         control: ───T──────@────────@───@────────────@────────────────
@@ -652,14 +623,12 @@ class CSwapGate(gate_features.InterchangeableQubitsGate, raw_types.Gate):
     def _unitary_(self) -> np.ndarray:
         return linalg.block_diag(np.diag([1, 1, 1, 1, 1]), np.array([[0, 1], [1, 0]]), np.diag([1]))
 
-    def _circuit_diagram_info_(
-        self, args: 'cirq.CircuitDiagramInfoArgs'
-    ) -> 'cirq.CircuitDiagramInfo':
+    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> cirq.CircuitDiagramInfo:
         if not args.use_unicode_characters:
             return protocols.CircuitDiagramInfo(('@', 'swap', 'swap'))
         return protocols.CircuitDiagramInfo(('@', '×', '×'))
 
-    def _qasm_(self, args: 'cirq.QasmArgs', qubits: Tuple['cirq.Qid', ...]) -> Optional[str]:
+    def _qasm_(self, args: cirq.QasmArgs, qubits: tuple[cirq.Qid, ...]) -> str | None:
         args.validate_version('2.0', '3.0')
         return args.format('cswap {0},{1},{2};\n', qubits[0], qubits[1], qubits[2])
 
@@ -682,11 +651,9 @@ class CSwapGate(gate_features.InterchangeableQubitsGate, raw_types.Gate):
 
     def controlled(
         self,
-        num_controls: Optional[int] = None,
-        control_values: Optional[
-            Union[cv.AbstractControlValues, Sequence[Union[int, Collection[int]]]]
-        ] = None,
-        control_qid_shape: Optional[Tuple[int, ...]] = None,
+        num_controls: int | None = None,
+        control_values: cv.AbstractControlValues | Sequence[int | Collection[int]] | None = None,
+        control_qid_shape: tuple[int, ...] | None = None,
     ) -> raw_types.Gate:
         """Returns a controlled `SWAP` with one additional control.
 

cirq/ops/three_qubit_gates_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 itertools
 
 import numpy as np
@@ -22,7 +24,7 @@ import cirq
 
 
 @pytest.mark.parametrize('eigen_gate_type', [cirq.CCXPowGate, cirq.CCZPowGate])
-def test_eigen_gates_consistent_protocols(eigen_gate_type):
+def test_eigen_gates_consistent_protocols(eigen_gate_type) -> None:
     cirq.testing.assert_eigengate_implements_consistent_protocols(eigen_gate_type)
 
 
@@ -36,18 +38,18 @@ def test_eigen_gates_consistent_protocols(eigen_gate_type):
         (cirq.CCZ),
     ),
 )
-def test_consistent_protocols(gate):
+def test_consistent_protocols(gate) -> None:
     cirq.testing.assert_implements_consistent_protocols(gate)
 
 
-def test_init():
+def test_init() -> None:
     assert (cirq.CCZ**0.5).exponent == 0.5
     assert (cirq.CCZ**0.25).exponent == 0.25
     assert (cirq.CCX**0.5).exponent == 0.5
     assert (cirq.CCX**0.25).exponent == 0.25
 
 
-def test_unitary():
+def test_unitary() -> None:
     assert cirq.has_unitary(cirq.CCX)
     np.testing.assert_allclose(
         cirq.unitary(cirq.CCX),
@@ -123,7 +125,7 @@ def test_unitary():
     )
 
 
-def test_str():
+def test_str() -> None:
     assert str(cirq.CCX) == 'TOFFOLI'
     assert str(cirq.TOFFOLI) == 'TOFFOLI'
     assert str(cirq.CSWAP) == 'FREDKIN'
@@ -134,7 +136,7 @@ def test_str():
     assert str(cirq.CCZ**0.5) == 'CCZ**0.5'
 
 
-def test_repr():
+def test_repr() -> None:
     assert repr(cirq.CCX) == 'cirq.TOFFOLI'
     assert repr(cirq.TOFFOLI) == 'cirq.TOFFOLI'
     assert repr(cirq.CSWAP) == 'cirq.FREDKIN'
@@ -145,7 +147,7 @@ def test_repr():
     assert repr(cirq.CCZ**0.5) == '(cirq.CCZ**0.5)'
 
 
-def test_eq():
+def test_eq() -> None:
     a, b, c, d = cirq.LineQubit.range(4)
     eq = cirq.testing.EqualsTester()
     eq.add_equality_group(cirq.CCZ(a, b, c), cirq.CCZ(a, c, b), cirq.CCZ(b, c, a))
@@ -163,7 +165,7 @@ def test_eq():
     eq.add_equality_group(cirq.CSWAP(b, a, c), cirq.CSWAP(b, c, a))
 
 
-def test_gate_equality():
+def test_gate_equality() -> None:
     eq = cirq.testing.EqualsTester()
     eq.add_equality_group(cirq.CSwapGate(), cirq.CSwapGate())
     eq.add_equality_group(cirq.CZPowGate(), cirq.CZPowGate())
@@ -171,7 +173,7 @@ def test_gate_equality():
     eq.add_equality_group(cirq.CCZPowGate(), cirq.CCZPowGate())
 
 
-def test_identity_multiplication():
+def test_identity_multiplication() -> None:
     a, b, c = cirq.LineQubit.range(3)
     assert cirq.CCX(a, b, c) * cirq.I(a) == cirq.CCX(a, b, c)
     assert cirq.CCX(a, b, c) * cirq.I(b) == cirq.CCX(a, b, c)
@@ -197,7 +199,7 @@ def test_identity_multiplication():
         ),
     ],
 )
-def test_decomposition_cost(op: cirq.Operation, max_two_cost: int):
+def test_decomposition_cost(op: cirq.Operation, max_two_cost: int) -> None:
     ops = tuple(cirq.flatten_op_tree(cirq.decompose(op)))
     two_cost = len([e for e in ops if len(e.qubits) == 2])
     over_cost = len([e for e in ops if len(e.qubits) > 2])
@@ -205,12 +207,12 @@ def test_decomposition_cost(op: cirq.Operation, max_two_cost: int):
     assert two_cost == max_two_cost
 
 
-def test_parameterized_ccz_decompose_no_global_phase():
+def test_parameterized_ccz_decompose_no_global_phase() -> None:
     decomposed_ops = cirq.decompose(cirq.CCZ(*cirq.LineQubit.range(3)) ** sympy.Symbol("theta"))
     assert not any(isinstance(op.gate, cirq.GlobalPhaseGate) for op in decomposed_ops)
 
 
-def test_diagonal_gate_property():
+def test_diagonal_gate_property() -> None:
     assert cirq.ThreeQubitDiagonalGate([2, 3, 5, 7, 0, 0, 0, 1]).diag_angles_radians == (
         (2, 3, 5, 7, 0, 0, 0, 1)
     )
@@ -220,7 +222,7 @@ def test_diagonal_gate_property():
     'gate',
     [cirq.CCX, cirq.CSWAP, cirq.CCZ, cirq.ThreeQubitDiagonalGate([2, 3, 5, 7, 11, 13, 17, 19])],
 )
-def test_decomposition_respects_locality(gate):
+def test_decomposition_respects_locality(gate) -> None:
     a = cirq.GridQubit(0, 0)
     b = cirq.GridQubit(1, 0)
     c = cirq.GridQubit(0, 1)
@@ -231,7 +233,7 @@ def test_decomposition_respects_locality(gate):
         dev.validate_circuit(circuit)
 
 
-def test_diagram():
+def test_diagram() -> None:
     a, b, c, d = cirq.LineQubit.range(4)
     circuit = cirq.Circuit(
         cirq.TOFFOLI(a, b, c),
@@ -295,7 +297,7 @@ def test_diagram():
     )
 
 
-def test_diagonal_exponent():
+def test_diagonal_exponent() -> None:
     diagonal_angles = [2, 3, 5, 7, 11, 13, 17, 19]
     diagonal_gate = cirq.ThreeQubitDiagonalGate(diagonal_angles)
 
@@ -308,7 +310,7 @@ def test_diagonal_exponent():
 
 
 @pytest.mark.parametrize('resolve_fn', [cirq.resolve_parameters, cirq.resolve_parameters_once])
-def test_resolve(resolve_fn):
+def test_resolve(resolve_fn) -> None:
     diagonal_angles = [2, 3, 5, 7, 11, 13, 17, 19]
     diagonal_gate = cirq.ThreeQubitDiagonalGate(
         diagonal_angles[:6] + [sympy.Symbol('a'), sympy.Symbol('b')]
@@ -325,7 +327,7 @@ def test_resolve(resolve_fn):
 
 
 @pytest.mark.parametrize('gate', [cirq.CCX, cirq.CCZ, cirq.CSWAP])
-def test_controlled_ops_consistency(gate):
+def test_controlled_ops_consistency(gate) -> None:
     a, b, c, d = cirq.LineQubit.range(4)
     assert gate.controlled(0) is gate
     assert gate(a, b, c).controlled_by(d) == gate(d, b, c).controlled_by(a)