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

cirq/ops/eigen_gate.py

@@ -11,24 +11,15 @@
 # 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 fractions
 import math
 import numbers
 from types import NotImplementedType
-from typing import (
-    AbstractSet,
-    Any,
-    cast,
-    Dict,
-    Iterable,
-    List,
-    NamedTuple,
-    Optional,
-    Tuple,
-    TYPE_CHECKING,
-    Union,
-)
+from typing import AbstractSet, Any, cast, Iterable, NamedTuple, TYPE_CHECKING
 
 import numpy as np
 import sympy
@@ -112,9 +103,15 @@ class EigenGate(raw_types.Gate):
                 `cirq.unitary(cirq.rx(pi))` equals -iX instead of X.
 
         Raises:
+            TypeError: If the supplied exponent is a string.
             ValueError: If the supplied exponent is a complex number with an
                 imaginary component.
         """
+        if isinstance(exponent, str):
+            raise TypeError(
+                "Gate exponent must be a number or sympy expression. "
+                f"Received a string instead: {exponent!r}"
+            )
         if isinstance(exponent, complex):
             if exponent.imag:
                 raise ValueError(f"Gate exponent must be real. Invalid Value: {exponent}")
@@ -131,20 +128,18 @@ class EigenGate(raw_types.Gate):
         return self._global_shift
 
     # virtual method
-    def _with_exponent(self, exponent: value.TParamVal) -> 'EigenGate':
+    def _with_exponent(self, exponent: value.TParamVal) -> EigenGate:
         """Return the same kind of gate, but with a different exponent.
 
         Child classes should override this method if they have an __init__
         method with a differing signature.
         """
-        # pylint: disable=unexpected-keyword-arg
         if self._global_shift == 0:
             return type(self)(exponent=exponent)
         return type(self)(exponent=exponent, global_shift=self._global_shift)
-        # pylint: enable=unexpected-keyword-arg
 
     def _diagram_exponent(
-        self, args: 'protocols.CircuitDiagramInfoArgs', *, ignore_global_phase: bool = True
+        self, args: protocols.CircuitDiagramInfoArgs, *, ignore_global_phase: bool = True
     ):
         """The exponent to use in circuit diagrams.
 
@@ -199,7 +194,7 @@ class EigenGate(raw_types.Gate):
         return result
 
     def _format_exponent_as_angle(
-        self, args: 'protocols.CircuitDiagramInfoArgs', order: int = 2
+        self, args: protocols.CircuitDiagramInfoArgs, order: int = 2
     ) -> str:
         """Returns string with exponent expressed as angle in radians.
 
@@ -216,7 +211,7 @@ class EigenGate(raw_types.Gate):
         return args.format_radians(radians=2 * pi * exponent / order)
 
     # virtual method
-    def _eigen_shifts(self) -> List[float]:
+    def _eigen_shifts(self) -> list[float]:
         """Describes the eigenvalues of the gate's matrix.
 
         By default, this just extracts the shifts by calling
@@ -232,7 +227,7 @@ class EigenGate(raw_types.Gate):
         return [e[0] for e in self._eigen_components()]
 
     @abc.abstractmethod
-    def _eigen_components(self) -> List[Union[EigenComponent, Tuple[float, np.ndarray]]]:
+    def _eigen_components(self) -> list[EigenComponent | tuple[float, np.ndarray]]:
         """Describes the eigendecomposition of the gate's matrix.
 
         Returns:
@@ -284,7 +279,7 @@ class EigenGate(raw_types.Gate):
                 ]
         """
 
-    def _period(self) -> Optional[float]:
+    def _period(self) -> float | None:
         """Determines how the exponent parameter is canonicalized when equating.
 
         Returns:
@@ -297,7 +292,12 @@ class EigenGate(raw_types.Gate):
         real_periods = [abs(2 / e) for e in exponents if e != 0]
         return _approximate_common_period(real_periods)
 
-    def __pow__(self, exponent: Union[float, sympy.Symbol]) -> 'EigenGate':
+    def __pow__(self, exponent: value.TParamVal) -> EigenGate:
+        if isinstance(exponent, str):
+            raise TypeError(
+                "Gate exponent must be a number or sympy expression. "
+                f"Received a string instead: {exponent!r}"
+            )
         new_exponent = protocols.mul(self._exponent, exponent, NotImplemented)
         if new_exponent is NotImplemented:
             return NotImplemented  # pragma: no cover
@@ -317,7 +317,7 @@ class EigenGate(raw_types.Gate):
         shifts = (f(self._exponent) * f(self._global_shift + e) for e in self._eigen_shifts())
         return tuple(s if symbolic(s) else value.PeriodicValue(f(s), 2) for s in shifts)
 
-    def _trace_distance_bound_(self) -> Optional[float]:
+    def _trace_distance_bound_(self) -> float | None:
         if protocols.is_parameterized(self._exponent):
             return None
         angles = np.pi * (np.array(self._eigen_shifts()) * self._exponent % 2)
@@ -326,7 +326,7 @@ class EigenGate(raw_types.Gate):
     def _has_unitary_(self) -> bool:
         return not self._is_parameterized_()
 
-    def _unitary_(self) -> Union[np.ndarray, NotImplementedType]:
+    def _unitary_(self) -> np.ndarray | NotImplementedType:
         if self._is_parameterized_():
             return NotImplemented
         e = cast(float, self._exponent)
@@ -344,7 +344,7 @@ class EigenGate(raw_types.Gate):
     def _parameter_names_(self) -> AbstractSet[str]:
         return protocols.parameter_names(self._exponent)
 
-    def _resolve_parameters_(self, resolver: 'cirq.ParamResolver', recursive: bool) -> 'EigenGate':
+    def _resolve_parameters_(self, resolver: cirq.ParamResolver, recursive: bool) -> EigenGate:
         exponent = resolver.value_of(self._exponent, recursive)
         if isinstance(exponent, numbers.Complex):
             if isinstance(exponent, numbers.Real):
@@ -369,7 +369,7 @@ class EigenGate(raw_types.Gate):
         other_without_phase._global_shift = 0
         return protocols.approx_eq(self_without_phase, other_without_phase, atol=atol)
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ['exponent', 'global_shift'])
 
     def _measurement_key_objs_(self):
@@ -384,8 +384,8 @@ def _lcm(vals: Iterable[int]) -> int:
 
 
 def _approximate_common_period(
-    periods: List[float], approx_denom: int = 60, reject_atol: float = 1e-8
-) -> Optional[float]:
+    periods: list[float], approx_denom: int = 60, reject_atol: float = 1e-8
+) -> float | None:
     """Finds a value that is nearly an integer multiple of multiple periods.
 
     The returned value should be the smallest non-negative number with this
@@ -429,7 +429,7 @@ def _approximate_common_period(
     return common
 
 
-def _common_rational_period(rational_periods: List[fractions.Fraction]) -> fractions.Fraction:
+def _common_rational_period(rational_periods: list[fractions.Fraction]) -> fractions.Fraction:
     """Finds the least common integer multiple of some fractions.
 
     The solution is the smallest positive integer c such that there

cirq/ops/eigen_gate_test.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import List, Tuple
+from __future__ import annotations
 
 import numpy as np
 import pytest
@@ -41,7 +41,7 @@ class CExpZinGate(cirq.EigenGate, cirq.testing.TwoQubitGate):
     def _with_exponent(self, exponent):
         return CExpZinGate(exponent)
 
-    def _eigen_components(self) -> List[Tuple[float, np.ndarray]]:
+    def _eigen_components(self) -> list[tuple[float, np.ndarray]]:
         return [
             (0, np.diag([1, 1, 0, 0])),
             (0.5, np.diag([0, 0, 1, 0])),
@@ -54,11 +54,11 @@ class ZGateDef(cirq.EigenGate, cirq.testing.SingleQubitGate):
     def exponent(self):
         return self._exponent
 
-    def _eigen_components(self) -> List[Tuple[float, np.ndarray]]:
+    def _eigen_components(self) -> list[tuple[float, np.ndarray]]:
         return [(0, np.diag([1, 0])), (1, np.diag([0, 1]))]
 
 
-def test_approximate_common_period():
+def test_approximate_common_period() -> None:
     from cirq.ops.eigen_gate import _approximate_common_period as f
 
     assert f([]) is None
@@ -71,13 +71,19 @@ def test_approximate_common_period():
     assert f([2.5]) == 2.5
     assert f([1.5, 2]) == 6
     assert f([2, 3]) == 6
-    assert abs(f([1 / 3, 2 / 3]) - 2 / 3) < 1e-8
-    assert abs(f([2 / 5, 3 / 5]) - 6 / 5) < 1e-8
+    f_x = f([1 / 3, 2 / 3])
+    assert f_x is not None
+    assert abs(f_x - 2 / 3) < 1e-8
+    f_x = f([2 / 5, 3 / 5])
+    assert f_x is not None
+    assert abs(f_x - 6 / 5) < 1e-8
     assert f([0.5, -0.5]) == 0.5
-    np.testing.assert_allclose(f([np.e]), np.e, atol=1e-8)
+    f_x = f([np.e])
+    assert f_x is not None
+    np.testing.assert_allclose(f_x, np.e, atol=1e-8)
 
 
-def test_init():
+def test_init() -> None:
     assert CExpZinGate(1).exponent == 1
     assert CExpZinGate(0.5).exponent == 0.5
     assert CExpZinGate(4.5).exponent == 4.5
@@ -91,7 +97,7 @@ def test_init():
     assert ZGateDef(exponent=0.5 + 0j).exponent == 0.5
 
 
-def test_eq():
+def test_eq() -> None:
     eq = cirq.testing.EqualsTester()
     eq.make_equality_group(lambda: CExpZinGate(quarter_turns=0.1))
     eq.add_equality_group(CExpZinGate(0), CExpZinGate(4), CExpZinGate(-4))
@@ -166,7 +172,7 @@ def test_eq():
     )
 
 
-def test_approx_eq():
+def test_approx_eq() -> None:
     assert cirq.approx_eq(CExpZinGate(1.5), CExpZinGate(1.5), atol=0.1)
     assert cirq.approx_eq(CExpZinGate(1.5), CExpZinGate(1.7), atol=0.3)
     assert not cirq.approx_eq(CExpZinGate(1.5), CExpZinGate(1.7), atol=0.1)
@@ -188,7 +194,7 @@ def test_approx_eq():
         )
 
 
-def test_approx_eq_periodic():
+def test_approx_eq_periodic() -> None:
     assert cirq.approx_eq(CExpZinGate(1.5), CExpZinGate(5.5), atol=1e-9)
     assert cirq.approx_eq(CExpZinGate(1.5), CExpZinGate(9.5), atol=1e-9)
     assert cirq.approx_eq(CExpZinGate(-2.5), CExpZinGate(1.5), atol=1e-9)
@@ -199,7 +205,7 @@ def test_approx_eq_periodic():
     assert cirq.approx_eq(CExpZinGate(0), CExpZinGate(4 - 1e-10), atol=1e-9)
 
 
-def test_period():
+def test_period() -> None:
     class Components(cirq.EigenGate, cirq.testing.TwoQubitGate):
         def __init__(self, a, b, c, d):
             super().__init__()
@@ -208,7 +214,7 @@ def test_period():
             self.c = c
             self.d = d
 
-        def _eigen_components(self) -> List[Tuple[float, np.ndarray]]:
+        def _eigen_components(self) -> list[tuple[float, np.ndarray]]:
             return [
                 (self.a, np.diag([1, 0, 0, 0])),
                 (self.b, np.diag([0, 1, 0, 0])),
@@ -224,14 +230,16 @@ def test_period():
     assert Components(1 / 3, 1 / 2, 1 / 5, 0)._period() == 60
     assert Components(1 / 6, 1 / 2, 1 / 5, 0)._period() == 60
     assert Components(np.e, np.pi, 0, 0)._period() is None
-    np.testing.assert_allclose(Components(np.e, np.e, 0, 0)._period(), 2 / np.e)
+    period = Components(np.e, np.e, 0, 0)._period()
+    assert period is not None
+    np.testing.assert_allclose(period, 2 / np.e)
     assert Components(-0.5, 0, 0, 0)._period() == 4
     assert Components(-0.5, 0.5, 0, 0)._period() == 4
     assert Components(-0.5, 0.5, 0.5, 0.5)._period() == 4
     assert Components(1, 1, -1, 1)._period() == 2
 
 
-def test_pow():
+def test_pow() -> None:
     assert CExpZinGate(0.25) ** 2 == CExpZinGate(0.5)
     assert CExpZinGate(0.25) ** -1 == CExpZinGate(-0.25)
     assert CExpZinGate(0.25) ** 0 == CExpZinGate(0)
@@ -240,17 +248,26 @@ def test_pow():
     assert ZGateDef(exponent=0.25, global_shift=0.5) ** 2 == ZGateDef(
         exponent=0.5, global_shift=0.5
     )
-    with pytest.raises(ValueError, match="real"):
+    with pytest.raises(ValueError, match="Gate exponent must be real."):
         assert ZGateDef(exponent=0.5) ** 0.5j
     assert ZGateDef(exponent=0.5) ** (1 + 0j) == ZGateDef(exponent=0.5)
 
+    with pytest.raises(TypeError, match="Gate exponent must be a number or sympy expression."):
+        assert ZGateDef(exponent=0.5) ** "text"
+
+    with pytest.raises(TypeError, match="Gate exponent must be a number or sympy expression."):
+        assert ZGateDef(exponent="text")
+
+    with pytest.raises(TypeError, match="Gate exponent must be a number or sympy expression."):
+        assert ZGateDef(exponent=sympy.Symbol('a')) ** "text"
+
 
-def test_inverse():
+def test_inverse() -> None:
     assert cirq.inverse(CExpZinGate(0.25)) == CExpZinGate(-0.25)
     assert cirq.inverse(CExpZinGate(sympy.Symbol('a'))) == CExpZinGate(-sympy.Symbol('a'))
 
 
-def test_trace_distance_bound():
+def test_trace_distance_bound() -> None:
     assert cirq.trace_distance_bound(CExpZinGate(0.001)) < 0.01
     assert cirq.trace_distance_bound(CExpZinGate(sympy.Symbol('a'))) == 1
     assert cirq.approx_eq(cirq.trace_distance_bound(CExpZinGate(2)), 1)
@@ -259,14 +276,14 @@ def test_trace_distance_bound():
         def _num_qubits_(self):  # pragma: no cover
             return 1
 
-        def _eigen_components(self) -> List[Tuple[float, np.ndarray]]:
+        def _eigen_components(self) -> list[tuple[float, np.ndarray]]:
             return [(0, np.array([[1, 0], [0, 0]])), (12, np.array([[0, 0], [0, 1]]))]
 
     for numerator in range(13):
         assert_has_consistent_trace_distance_bound(E() ** (numerator / 12))
 
 
-def test_extrapolate():
+def test_extrapolate() -> None:
     h = CExpZinGate(2)
     assert cirq.pow(h, 1.5) is not None
     assert cirq.inverse(h, None) is not None
@@ -280,7 +297,7 @@ def test_extrapolate():
     assert cirq.inverse(s) == CExpZinGate(-sympy.Symbol('a'))
 
 
-def test_matrix():
+def test_matrix() -> None:
     for n in [1, 2, 3, 4, 0.0001, 3.9999]:
         assert cirq.has_unitary(CExpZinGate(n))
 
@@ -326,11 +343,11 @@ def test_matrix():
     )
 
 
-def test_matrix_is_exact_for_quarter_turn():
+def test_matrix_is_exact_for_quarter_turn() -> None:
     np.testing.assert_equal(cirq.unitary(CExpZinGate(1)), np.diag([1, 1, 1j, -1j]))
 
 
-def test_is_parameterized():
+def test_is_parameterized() -> None:
     assert not cirq.is_parameterized(CExpZinGate(0))
     assert not cirq.is_parameterized(CExpZinGate(1))
     assert not cirq.is_parameterized(CExpZinGate(3))
@@ -338,7 +355,7 @@ def test_is_parameterized():
 
 
 @pytest.mark.parametrize('resolve_fn', [cirq.resolve_parameters, cirq.resolve_parameters_once])
-def test_resolve_parameters(resolve_fn):
+def test_resolve_parameters(resolve_fn) -> None:
     assert resolve_fn(
         CExpZinGate(sympy.Symbol('a')), cirq.ParamResolver({'a': 0.5})
     ) == CExpZinGate(0.5)
@@ -349,9 +366,9 @@ def test_resolve_parameters(resolve_fn):
         resolve_fn(CExpZinGate(sympy.Symbol('a')), cirq.ParamResolver({'a': 0.5j}))
 
 
-def test_diagram_period():
+def test_diagram_period() -> None:
     class ShiftyGate(cirq.EigenGate, cirq.testing.SingleQubitGate):
-        def _eigen_components(self) -> List[Tuple[float, np.ndarray]]:
+        def _eigen_components(self) -> list[tuple[float, np.ndarray]]:
             raise NotImplementedError()
 
         def __init__(self, e, *shifts):
@@ -388,7 +405,7 @@ class WeightedZPowGate(cirq.EigenGate, cirq.testing.SingleQubitGate):
         self.weight = weight
         super().__init__(**kwargs)
 
-    def _eigen_components(self) -> List[Tuple[float, np.ndarray]]:
+    def _eigen_components(self) -> list[tuple[float, np.ndarray]]:
         return [(0, np.diag([1, 0])), (self.weight, np.diag([0, 1]))]
 
     def _with_exponent(self, exponent):
@@ -419,5 +436,5 @@ class WeightedZPowGate(cirq.EigenGate, cirq.testing.SingleQubitGate):
         (cirq.Z**2, cirq.Z ** (4 + 1e-10), True),
     ],
 )
-def test_equal_up_to_global_phase(gate1, gate2, eq_up_to_global_phase):
+def test_equal_up_to_global_phase(gate1, gate2, eq_up_to_global_phase) -> None:
     assert cirq.equal_up_to_global_phase(gate1, gate2) == eq_up_to_global_phase

cirq/ops/fourier_transform.py

@@ -12,7 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import AbstractSet, Any, Dict, Union
+from __future__ import annotations
+
+from typing import AbstractSet, Any
 
 import numpy as np
 import sympy
@@ -52,7 +54,7 @@ class QuantumFourierTransformGate(raw_types.Gate):
         self._num_qubits = num_qubits
         self._without_reverse = without_reverse
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return {'num_qubits': self._num_qubits, 'without_reverse': self._without_reverse}
 
     def _value_equality_values_(self):
@@ -87,9 +89,7 @@ class QuantumFourierTransformGate(raw_types.Gate):
             f'without_reverse={self._without_reverse!r})'
         )
 
-    def _circuit_diagram_info_(
-        self, args: 'cirq.CircuitDiagramInfoArgs'
-    ) -> 'cirq.CircuitDiagramInfo':
+    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> cirq.CircuitDiagramInfo:
         return cirq.CircuitDiagramInfo(
             wire_symbols=(str(self),) + tuple(f'#{k+1}' for k in range(1, self._num_qubits)),
             exponent_qubit_index=0,
@@ -112,15 +112,15 @@ class PhaseGradientGate(raw_types.Gate):
     This gate makes up a portion of the quantum fourier transform.
     """
 
-    def __init__(self, *, num_qubits: int, exponent: Union[float, sympy.Basic]):
+    def __init__(self, *, num_qubits: int, exponent: float | sympy.Basic):
         self._num_qubits = num_qubits
         self._exponent = exponent
 
     @property
-    def exponent(self) -> Union[float, sympy.Basic]:
+    def exponent(self) -> float | sympy.Basic:
         return self._exponent
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return {'num_qubits': self._num_qubits, 'exponent': self.exponent}
 
     def _value_equality_values_(self):
@@ -133,7 +133,7 @@ class PhaseGradientGate(raw_types.Gate):
         for i, q in enumerate(qubits):
             yield cirq.Z(q) ** (self.exponent / 2**i)
 
-    def _apply_unitary_(self, args: 'cirq.ApplyUnitaryArgs'):
+    def _apply_unitary_(self, args: cirq.ApplyUnitaryArgs):
         if isinstance(self.exponent, sympy.Basic):
             return NotImplemented
 
@@ -167,8 +167,8 @@ class PhaseGradientGate(raw_types.Gate):
         return cirq.parameter_names(self.exponent)
 
     def _resolve_parameters_(
-        self, resolver: 'cirq.ParamResolver', recursive: bool
-    ) -> 'PhaseGradientGate':
+        self, resolver: cirq.ParamResolver, recursive: bool
+    ) -> PhaseGradientGate:
         new_exponent = cirq.resolve_parameters(self.exponent, resolver, recursive)
         return PhaseGradientGate(num_qubits=self._num_qubits, exponent=new_exponent)
 
@@ -182,9 +182,7 @@ class PhaseGradientGate(raw_types.Gate):
             f'exponent={_compat.proper_repr(self.exponent)})'
         )
 
-    def _circuit_diagram_info_(
-        self, args: 'cirq.CircuitDiagramInfoArgs'
-    ) -> 'cirq.CircuitDiagramInfo':
+    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> cirq.CircuitDiagramInfo:
         return cirq.CircuitDiagramInfo(
             wire_symbols=('Grad',) + tuple(f'#{k+1}' for k in range(1, self._num_qubits)),
             exponent=self.exponent,
@@ -192,9 +190,7 @@ class PhaseGradientGate(raw_types.Gate):
         )
 
 
-def qft(
-    *qubits: 'cirq.Qid', without_reverse: bool = False, inverse: bool = False
-) -> 'cirq.Operation':
+def qft(*qubits: cirq.Qid, without_reverse: bool = False, inverse: bool = False) -> cirq.Operation:
     """The quantum Fourier transform.
 
     Transforms a qubit register from the computational basis to the frequency
@@ -216,6 +212,4 @@ def qft(
         A `cirq.Operation` applying the qft to the given qubits.
     """
     result = QuantumFourierTransformGate(len(qubits), without_reverse=without_reverse).on(*qubits)
-    if inverse:
-        result = cirq.inverse(result)
-    return result
+    return cirq.inverse(result) if inverse else result

cirq/ops/fourier_transform_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
@@ -19,7 +21,7 @@ import sympy
 import cirq
 
 
-def test_phase_gradient():
+def test_phase_gradient() -> None:
     np.testing.assert_allclose(
         cirq.unitary(cirq.PhaseGradientGate(num_qubits=2, exponent=1)), np.diag([1, 1j, -1, -1j])
     )
@@ -31,7 +33,7 @@ def test_phase_gradient():
 
 
 @pytest.mark.parametrize('resolve_fn', [cirq.resolve_parameters, cirq.resolve_parameters_once])
-def test_phase_gradient_symbolic(resolve_fn):
+def test_phase_gradient_symbolic(resolve_fn) -> None:
     a = cirq.PhaseGradientGate(num_qubits=2, exponent=0.5)
     b = cirq.PhaseGradientGate(num_qubits=2, exponent=sympy.Symbol('t'))
     assert not cirq.is_parameterized(a)
@@ -43,22 +45,22 @@ def test_phase_gradient_symbolic(resolve_fn):
     assert resolve_fn(b, {'t': 0.25}) == cirq.PhaseGradientGate(num_qubits=2, exponent=0.25)
 
 
-def test_str():
+def test_str() -> None:
     assert str(cirq.PhaseGradientGate(num_qubits=2, exponent=0.5)) == 'Grad[2]^0.5'
     assert str(cirq.PhaseGradientGate(num_qubits=2, exponent=1)) == 'Grad[2]'
 
 
-def test_phase_gradient_gate_repr():
+def test_phase_gradient_gate_repr() -> None:
     a = cirq.PhaseGradientGate(num_qubits=2, exponent=0.5)
     cirq.testing.assert_equivalent_repr(a)
 
 
-def test_quantum_fourier_transform_gate_repr():
+def test_quantum_fourier_transform_gate_repr() -> None:
     b = cirq.QuantumFourierTransformGate(num_qubits=2, without_reverse=False)
     cirq.testing.assert_equivalent_repr(b)
 
 
-def test_pow():
+def test_pow() -> None:
     a = cirq.PhaseGradientGate(num_qubits=2, exponent=0.5)
     assert a**0.5 == cirq.PhaseGradientGate(num_qubits=2, exponent=0.25)
     assert a ** sympy.Symbol('t') == cirq.PhaseGradientGate(
@@ -66,7 +68,7 @@ def test_pow():
     )
 
 
-def test_qft():
+def test_qft() -> None:
     # fmt: off
     np.testing.assert_allclose(
         cirq.unitary(cirq.qft(*cirq.LineQubit.range(2))),
@@ -103,9 +105,10 @@ def test_qft():
         atol=1e-8,
     )
 
+    arr = np.array([[1, 1, 1, 1], [1, -1j, -1, 1j], [1, -1, 1, -1], [1, 1j, -1, -1j]]) / 2
     np.testing.assert_allclose(
-        cirq.unitary(cirq.qft(*cirq.LineQubit.range(2)) ** -1),
-        np.array([[1, 1, 1, 1], [1, -1j, -1, 1j], [1, -1, 1, -1], [1, 1j, -1, -1j]]) / 2,
+        cirq.unitary(cirq.qft(*cirq.LineQubit.range(2)) ** -1),  # type: ignore[operator]
+        arr,  # type: ignore[arg-type]
         atol=1e-8,
     )
 
@@ -116,15 +119,15 @@ def test_qft():
             )
 
 
-def test_inverse():
+def test_inverse() -> None:
     a, b, c = cirq.LineQubit.range(3)
-    assert cirq.qft(a, b, c, inverse=True) == cirq.qft(a, b, c) ** -1
+    assert cirq.qft(a, b, c, inverse=True) == cirq.qft(a, b, c) ** -1  # type: ignore[operator]
     assert cirq.qft(a, b, c, inverse=True, without_reverse=True) == cirq.inverse(
         cirq.qft(a, b, c, without_reverse=True)
     )
 
 
-def test_circuit_diagram():
+def test_circuit_diagram() -> None:
     cirq.testing.assert_has_diagram(
         cirq.Circuit(cirq.decompose_once(cirq.qft(*cirq.LineQubit.range(4)))),
         """