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

cirq/ops/fsim_gate.py

@@ -11,6 +11,7 @@
 # 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.
+
 """Defines the fermionic simulation gate.
 
 This is the family of two-qubit gates that preserve excitations (number of ON
@@ -21,9 +22,11 @@ context of chemistry the electron count is conserved over time. This property
 applies more generally to fermions, thus the name of the gate.
 """
 
+from __future__ import annotations
+
 import cmath
 import math
-from typing import AbstractSet, Any, Dict, Iterator, Optional, Tuple
+from typing import AbstractSet, Any, Iterator
 
 import numpy as np
 import sympy
@@ -34,7 +37,7 @@ from cirq._compat import proper_repr
 from cirq.ops import gate_features, raw_types
 
 
-def _canonicalize(value: 'cirq.TParamVal') -> 'cirq.TParamVal':
+def _canonicalize(value: cirq.TParamVal) -> cirq.TParamVal:
     """Assumes value is 2π-periodic and shifts it into [-π, π)."""
     if protocols.is_parameterized(value):
         return value
@@ -42,12 +45,12 @@ def _canonicalize(value: 'cirq.TParamVal') -> 'cirq.TParamVal':
     return value - period * np.floor((value + np.pi) / period)
 
 
-def _zero_mod_pi(param: 'cirq.TParamVal') -> bool:
+def _zero_mod_pi(param: cirq.TParamVal) -> bool:
     """Returns True iff param, assumed to be in [-pi, pi), is 0 (mod pi)."""
     return param in (0.0, -np.pi, -sympy.pi)
 
 
-def _half_pi_mod_pi(param: 'cirq.TParamVal') -> bool:
+def _half_pi_mod_pi(param: cirq.TParamVal) -> bool:
     """Returns True iff param, assumed to be in [-pi, pi), is pi/2 (mod pi)."""
     return param in (-np.pi / 2, np.pi / 2, -sympy.pi / 2, sympy.pi / 2)
 
@@ -90,7 +93,7 @@ class FSimGate(gate_features.InterchangeableQubitsGate, raw_types.Gate):
     FSimGate(θ, φ) = ISWAP**(-2θ/π) CZPowGate(exponent=-φ/π)
     """
 
-    def __init__(self, theta: 'cirq.TParamVal', phi: 'cirq.TParamVal') -> None:
+    def __init__(self, theta: cirq.TParamVal, phi: cirq.TParamVal) -> None:
         """Inits FSimGate.
 
         Args:
@@ -106,11 +109,11 @@ class FSimGate(gate_features.InterchangeableQubitsGate, raw_types.Gate):
         self._phi = _canonicalize(phi)
 
     @property
-    def theta(self) -> 'cirq.TParamVal':
+    def theta(self) -> cirq.TParamVal:
         return self._theta
 
     @property
-    def phi(self) -> 'cirq.TParamVal':
+    def phi(self) -> cirq.TParamVal:
         return self._phi
 
     def _num_qubits_(self) -> int:
@@ -128,7 +131,7 @@ class FSimGate(gate_features.InterchangeableQubitsGate, raw_types.Gate):
     def _has_unitary_(self):
         return not self._is_parameterized_()
 
-    def _unitary_(self) -> Optional[np.ndarray]:
+    def _unitary_(self) -> np.ndarray | None:
         if self._is_parameterized_():
             return None
         a = math.cos(self.theta)
@@ -162,15 +165,13 @@ class FSimGate(gate_features.InterchangeableQubitsGate, raw_types.Gate):
             }
         )
 
-    def _resolve_parameters_(
-        self, resolver: 'cirq.ParamResolver', recursive: bool
-    ) -> 'cirq.FSimGate':
+    def _resolve_parameters_(self, resolver: cirq.ParamResolver, recursive: bool) -> cirq.FSimGate:
         return FSimGate(
             protocols.resolve_parameters(self.theta, resolver, recursive),
             protocols.resolve_parameters(self.phi, resolver, recursive),
         )
 
-    def _apply_unitary_(self, args: 'cirq.ApplyUnitaryArgs') -> Optional[np.ndarray]:
+    def _apply_unitary_(self, args: cirq.ApplyUnitaryArgs) -> np.ndarray | None:
         if cirq.is_parameterized(self):
             return None
         if self.theta != 0:
@@ -187,7 +188,7 @@ class FSimGate(gate_features.InterchangeableQubitsGate, raw_types.Gate):
             out[ii] *= cmath.exp(-1j * self.phi)
         return out
 
-    def _decompose_(self, qubits) -> Iterator['cirq.OP_TREE']:
+    def _decompose_(self, qubits) -> Iterator[cirq.OP_TREE]:
         a, b = qubits
         xx = cirq.XXPowGate(exponent=self.theta / np.pi, global_shift=-0.5)
         yy = cirq.YYPowGate(exponent=self.theta / np.pi, global_shift=-0.5)
@@ -195,12 +196,12 @@ class FSimGate(gate_features.InterchangeableQubitsGate, raw_types.Gate):
         yield yy(a, b)
         yield cirq.CZ(a, b) ** (-self.phi / np.pi)
 
-    def _circuit_diagram_info_(self, args: 'cirq.CircuitDiagramInfoArgs') -> Tuple[str, ...]:
+    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> tuple[str, ...]:
         t = args.format_radians(self.theta)
         p = args.format_radians(self.phi)
         return f'FSim({t}, {p})', f'FSim({t}, {p})'
 
-    def __pow__(self, power) -> 'FSimGate':
+    def __pow__(self, power) -> FSimGate:
         return FSimGate(cirq.mul(self.theta, power), cirq.mul(self.phi, power))
 
     def __repr__(self) -> str:
@@ -208,7 +209,7 @@ class FSimGate(gate_features.InterchangeableQubitsGate, raw_types.Gate):
         p = proper_repr(self.phi)
         return f'cirq.FSimGate(theta={t}, phi={p})'
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ['theta', 'phi'])
 
 
@@ -275,11 +276,11 @@ class PhasedFSimGate(gate_features.InterchangeableQubitsGate, raw_types.Gate):
 
     def __init__(
         self,
-        theta: 'cirq.TParamVal',
-        zeta: 'cirq.TParamVal' = 0.0,
-        chi: 'cirq.TParamVal' = 0.0,
-        gamma: 'cirq.TParamVal' = 0.0,
-        phi: 'cirq.TParamVal' = 0.0,
+        theta: cirq.TParamVal,
+        zeta: cirq.TParamVal = 0.0,
+        chi: cirq.TParamVal = 0.0,
+        gamma: cirq.TParamVal = 0.0,
+        phi: cirq.TParamVal = 0.0,
     ) -> None:
         """Inits PhasedFSimGate.
 
@@ -302,32 +303,32 @@ class PhasedFSimGate(gate_features.InterchangeableQubitsGate, raw_types.Gate):
         self._phi = _canonicalize(phi)
 
     @property
-    def theta(self) -> 'cirq.TParamVal':
+    def theta(self) -> cirq.TParamVal:
         return self._theta
 
     @property
-    def zeta(self) -> 'cirq.TParamVal':
+    def zeta(self) -> cirq.TParamVal:
         return self._zeta
 
     @property
-    def chi(self) -> 'cirq.TParamVal':
+    def chi(self) -> cirq.TParamVal:
         return self._chi
 
     @property
-    def gamma(self) -> 'cirq.TParamVal':
+    def gamma(self) -> cirq.TParamVal:
         return self._gamma
 
     @property
-    def phi(self) -> 'cirq.TParamVal':
+    def phi(self) -> cirq.TParamVal:
         return self._phi
 
     @staticmethod
     def from_fsim_rz(
-        theta: 'cirq.TParamVal',
-        phi: 'cirq.TParamVal',
-        rz_angles_before: Tuple['cirq.TParamVal', 'cirq.TParamVal'],
-        rz_angles_after: Tuple['cirq.TParamVal', 'cirq.TParamVal'],
-    ) -> 'PhasedFSimGate':
+        theta: cirq.TParamVal,
+        phi: cirq.TParamVal,
+        rz_angles_before: tuple[cirq.TParamVal, cirq.TParamVal],
+        rz_angles_after: tuple[cirq.TParamVal, cirq.TParamVal],
+    ) -> PhasedFSimGate:
         """Creates PhasedFSimGate using an alternate parametrization.
 
         Args:
@@ -348,7 +349,7 @@ class PhasedFSimGate(gate_features.InterchangeableQubitsGate, raw_types.Gate):
         return PhasedFSimGate(theta, zeta, chi, gamma, phi)
 
     @staticmethod
-    def from_matrix(u: np.ndarray) -> Optional['PhasedFSimGate']:
+    def from_matrix(u: np.ndarray) -> PhasedFSimGate | None:
         """Contruct a PhasedFSimGate from unitary.
 
         Args:
@@ -387,14 +388,14 @@ class PhasedFSimGate(gate_features.InterchangeableQubitsGate, raw_types.Gate):
         return None
 
     @property
-    def rz_angles_before(self) -> Tuple['cirq.TParamVal', 'cirq.TParamVal']:
+    def rz_angles_before(self) -> tuple[cirq.TParamVal, cirq.TParamVal]:
         """Returns 2-tuple of phase angles applied to qubits before FSimGate."""
         b0 = (-self.gamma + self.zeta + self.chi) / 2.0
         b1 = (-self.gamma - self.zeta - self.chi) / 2.0
         return b0, b1
 
     @property
-    def rz_angles_after(self) -> Tuple['cirq.TParamVal', 'cirq.TParamVal']:
+    def rz_angles_after(self) -> tuple[cirq.TParamVal, cirq.TParamVal]:
         """Returns 2-tuple of phase angles applied to qubits after FSimGate."""
         a0 = (-self.gamma + self.zeta - self.chi) / 2.0
         a1 = (-self.gamma - self.zeta + self.chi) / 2.0
@@ -433,7 +434,7 @@ class PhasedFSimGate(gate_features.InterchangeableQubitsGate, raw_types.Gate):
     def _has_unitary_(self):
         return not self._is_parameterized_()
 
-    def _unitary_(self) -> Optional[np.ndarray]:
+    def _unitary_(self) -> np.ndarray | None:
         if self._is_parameterized_():
             return None
         a = math.cos(self.theta)
@@ -456,8 +457,8 @@ class PhasedFSimGate(gate_features.InterchangeableQubitsGate, raw_types.Gate):
         # fmt: on
 
     def _resolve_parameters_(
-        self, resolver: 'cirq.ParamResolver', recursive: bool
-    ) -> 'cirq.PhasedFSimGate':
+        self, resolver: cirq.ParamResolver, recursive: bool
+    ) -> cirq.PhasedFSimGate:
         return PhasedFSimGate(
             protocols.resolve_parameters(self.theta, resolver, recursive),
             protocols.resolve_parameters(self.zeta, resolver, recursive),
@@ -466,7 +467,7 @@ class PhasedFSimGate(gate_features.InterchangeableQubitsGate, raw_types.Gate):
             protocols.resolve_parameters(self.phi, resolver, recursive),
         )
 
-    def _apply_unitary_(self, args: 'cirq.ApplyUnitaryArgs') -> Optional[np.ndarray]:
+    def _apply_unitary_(self, args: cirq.ApplyUnitaryArgs) -> np.ndarray | None:
         if cirq.is_parameterized(self):
             return None
         oi = args.subspace_index(0b01)
@@ -491,7 +492,7 @@ class PhasedFSimGate(gate_features.InterchangeableQubitsGate, raw_types.Gate):
             out[ii] *= f * f
         return out
 
-    def _decompose_(self, qubits) -> Iterator['cirq.OP_TREE']:
+    def _decompose_(self, qubits) -> Iterator[cirq.OP_TREE]:
         """Decomposes self into Z rotations and FSimGate.
 
         Note that Z rotations returned by this method have unusual global phase
@@ -500,7 +501,7 @@ class PhasedFSimGate(gate_features.InterchangeableQubitsGate, raw_types.Gate):
         makes the top left element of the matrix equal to 1.
         """
 
-        def to_exponent(angle_rads: 'cirq.TParamVal') -> 'cirq.TParamVal':
+        def to_exponent(angle_rads: cirq.TParamVal) -> cirq.TParamVal:
             """Divides angle_rads by symbolic or numerical pi."""
             pi = sympy.pi if protocols.is_parameterized(angle_rads) else np.pi
             return angle_rads / pi
@@ -514,7 +515,7 @@ class PhasedFSimGate(gate_features.InterchangeableQubitsGate, raw_types.Gate):
         yield cirq.Z(q0) ** to_exponent(after[0])
         yield cirq.Z(q1) ** to_exponent(after[1])
 
-    def _circuit_diagram_info_(self, args: 'cirq.CircuitDiagramInfoArgs') -> Tuple[str, ...]:
+    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> tuple[str, ...]:
         theta = args.format_radians(self.theta)
         zeta = args.format_radians(self.zeta)
         chi = args.format_radians(self.chi)
@@ -536,7 +537,7 @@ class PhasedFSimGate(gate_features.InterchangeableQubitsGate, raw_types.Gate):
             f'gamma={gamma}, phi={phi})'
         )
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ['theta', 'zeta', 'chi', 'gamma', 'phi'])
 
     def _num_qubits_(self) -> int:

cirq/ops/fsim_gate_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_fsim_init():
+def test_fsim_init() -> None:
     f = cirq.FSimGate(1, 2)
     assert f.theta == 1
     assert f.phi == 2
@@ -33,7 +35,7 @@ def test_fsim_init():
     assert f3.phi == -5 + 2 * np.pi
 
 
-def test_fsim_eq():
+def test_fsim_eq() -> None:
     eq = cirq.testing.EqualsTester()
     a, b = cirq.LineQubit.range(2)
 
@@ -45,7 +47,7 @@ def test_fsim_eq():
     eq.add_equality_group(cirq.FSimGate(np.pi, np.pi), cirq.FSimGate(-np.pi, -np.pi))
 
 
-def test_fsim_approx_eq():
+def test_fsim_approx_eq() -> None:
     assert cirq.approx_eq(cirq.FSimGate(1, 2), cirq.FSimGate(1.00001, 2.00001), atol=0.01)
 
 
@@ -60,12 +62,12 @@ def test_fsim_approx_eq():
         (np.pi / 2, 0.5),
     ],
 )
-def test_fsim_consistent(theta, phi):
+def test_fsim_consistent(theta, phi) -> None:
     gate = cirq.FSimGate(theta=theta, phi=phi)
     cirq.testing.assert_implements_consistent_protocols(gate)
 
 
-def test_fsim_circuit():
+def test_fsim_circuit() -> None:
     a, b = cirq.LineQubit.range(2)
     c = cirq.Circuit(
         cirq.FSimGate(np.pi / 2, np.pi).on(a, b), cirq.FSimGate(-np.pi, np.pi / 2).on(a, b)
@@ -109,7 +111,7 @@ def test_fsim_circuit():
 
 
 @pytest.mark.parametrize('resolve_fn', [cirq.resolve_parameters, cirq.resolve_parameters_once])
-def test_fsim_resolve(resolve_fn):
+def test_fsim_resolve(resolve_fn) -> None:
     f = cirq.FSimGate(sympy.Symbol('a'), sympy.Symbol('b'))
     assert cirq.is_parameterized(f)
 
@@ -122,7 +124,7 @@ def test_fsim_resolve(resolve_fn):
     assert not cirq.is_parameterized(f)
 
 
-def test_fsim_unitary():
+def test_fsim_unitary() -> None:
     # fmt: off
     np.testing.assert_allclose(
         cirq.unitary(cirq.FSimGate(theta=0, phi=0)),
@@ -265,7 +267,7 @@ def test_fsim_unitary():
         (3.5 * np.pi, 4 * np.pi),
     ),
 )
-def test_fsim_iswap_cphase(theta, phi):
+def test_fsim_iswap_cphase(theta, phi) -> None:
     q0, q1 = cirq.NamedQubit('q0'), cirq.NamedQubit('q1')
     iswap = cirq.ISWAP ** (-theta * 2 / np.pi)
     cphase = cirq.CZPowGate(exponent=-phi / np.pi)
@@ -274,16 +276,16 @@ def test_fsim_iswap_cphase(theta, phi):
     assert np.allclose(cirq.unitary(iswap_cphase), cirq.unitary(fsim))
 
 
-def test_fsim_repr():
+def test_fsim_repr() -> None:
     f = cirq.FSimGate(sympy.Symbol('a'), sympy.Symbol('b'))
     cirq.testing.assert_equivalent_repr(f)
 
 
-def test_fsim_json_dict():
+def test_fsim_json_dict() -> None:
     assert cirq.FSimGate(theta=0.123, phi=0.456)._json_dict_() == {'theta': 0.123, 'phi': 0.456}
 
 
-def test_phased_fsim_init():
+def test_phased_fsim_init() -> None:
     f = cirq.PhasedFSimGate(1, 2, 3, 4, 5)
     assert f.theta == 1
     assert f.zeta == 2
@@ -307,7 +309,7 @@ def test_phased_fsim_init():
         (np.pi / 5, np.pi / 6, (0.1, 0.2), (0.3, 0.5)),
     ),
 )
-def test_phased_fsim_from_fsim_rz(theta, phi, rz_angles_before, rz_angles_after):
+def test_phased_fsim_from_fsim_rz(theta, phi, rz_angles_before, rz_angles_after) -> None:
     f = cirq.PhasedFSimGate.from_fsim_rz(theta, phi, rz_angles_before, rz_angles_after)
     q0, q1 = cirq.LineQubit.range(2)
     c = cirq.Circuit(
@@ -330,7 +332,7 @@ def test_phased_fsim_from_fsim_rz(theta, phi, rz_angles_before, rz_angles_after)
         ((np.pi / 5, -np.pi / 3), (0, np.pi / 2)),
     ),
 )
-def test_phased_fsim_recreate_from_phase_angles(rz_angles_before, rz_angles_after):
+def test_phased_fsim_recreate_from_phase_angles(rz_angles_before, rz_angles_after) -> None:
     f = cirq.PhasedFSimGate.from_fsim_rz(np.pi / 3, np.pi / 5, rz_angles_before, rz_angles_after)
     f2 = cirq.PhasedFSimGate.from_fsim_rz(f.theta, f.phi, f.rz_angles_before, f.rz_angles_after)
     assert cirq.approx_eq(f, f2)
@@ -346,7 +348,7 @@ def test_phased_fsim_recreate_from_phase_angles(rz_angles_before, rz_angles_afte
         ((np.pi, np.pi / 6), (-np.pi / 2, 0)),
     ),
 )
-def test_phased_fsim_phase_angle_symmetry(rz_angles_before, rz_angles_after):
+def test_phased_fsim_phase_angle_symmetry(rz_angles_before, rz_angles_after) -> None:
     f = cirq.PhasedFSimGate.from_fsim_rz(np.pi / 3, np.pi / 5, rz_angles_before, rz_angles_after)
     for d in (-10, -7, -2 * np.pi, -0.2, 0, 0.1, 0.2, np.pi, 8, 20):
         rz_angles_before2 = (rz_angles_before[0] + d, rz_angles_before[1] + d)
@@ -357,7 +359,7 @@ def test_phased_fsim_phase_angle_symmetry(rz_angles_before, rz_angles_after):
         assert cirq.approx_eq(f, f2)
 
 
-def test_phased_fsim_eq():
+def test_phased_fsim_eq() -> None:
     eq = cirq.testing.EqualsTester()
     a, b = cirq.LineQubit.range(2)
     r, s = sympy.Symbol('r'), sympy.Symbol('s')
@@ -435,7 +437,7 @@ def test_phased_fsim_eq():
         (cirq.PhasedFSimGate(1, np.pi / 2, 0, 4, 5), False),
     ),
 )
-def test_qubit_interchangeability(gate, interchangeable):
+def test_qubit_interchangeability(gate, interchangeable) -> None:
     a, b = cirq.LineQubit.range(2)
     c1 = cirq.Circuit(gate.on(a, b))
     c2 = cirq.Circuit(cirq.SWAP(a, b), gate.on(a, b), cirq.SWAP(a, b))
@@ -444,7 +446,7 @@ def test_qubit_interchangeability(gate, interchangeable):
     assert np.all(u1 == u2) == interchangeable
 
 
-def test_phased_fsim_approx_eq():
+def test_phased_fsim_approx_eq() -> None:
     assert cirq.approx_eq(
         cirq.PhasedFSimGate(1, 2, 3, 4, 5),
         cirq.PhasedFSimGate(1.00001, 2.00001, 3.00001, 4.00004, 5.00005),
@@ -469,12 +471,12 @@ def test_phased_fsim_approx_eq():
         (np.pi, 0, 0, sympy.Symbol('a'), 0),
     ],
 )
-def test_phased_fsim_consistent(theta, zeta, chi, gamma, phi):
+def test_phased_fsim_consistent(theta, zeta, chi, gamma, phi) -> None:
     gate = cirq.PhasedFSimGate(theta=theta, zeta=zeta, chi=chi, gamma=gamma, phi=phi)
     cirq.testing.assert_implements_consistent_protocols(gate)
 
 
-def test_phased_fsim_circuit():
+def test_phased_fsim_circuit() -> None:
     a, b = cirq.LineQubit.range(2)
     c = cirq.Circuit(
         cirq.PhasedFSimGate(np.pi / 2, np.pi, np.pi / 2, 0, -np.pi / 4).on(a, b),
@@ -488,7 +490,6 @@ def test_phased_fsim_circuit():
 1: ───PhFSim(0.5π, -π, 0.5π, 0, -0.25π)───PhFSim(-π, 0.5π, 0.1π, 0.2π, 0.3π)───
     """,
     )
-    # pylint: disable=line-too-long
     cirq.testing.assert_has_diagram(
         c,
         """
@@ -504,11 +505,10 @@ def test_phased_fsim_circuit():
 0: ---PhFSim(1.5707963267948966, -pi, 1.5707963267948966, 0, -0.7853981633974483)---PhFSim(-pi, 1.5707963267948966, 0.3141592653589793, 0.6283185307179586, 0.9424777960769379)---
       |                                                                             |
 1: ---PhFSim(1.5707963267948966, -pi, 1.5707963267948966, 0, -0.7853981633974483)---PhFSim(-pi, 1.5707963267948966, 0.3141592653589793, 0.6283185307179586, 0.9424777960769379)---
-""",
+""",  # noqa: E501
         use_unicode_characters=False,
         precision=None,
     )
-    # pylint: enable=line-too-long
     c = cirq.Circuit(
         cirq.PhasedFSimGate(
             sympy.Symbol('a') + sympy.Symbol('b'),
@@ -529,7 +529,7 @@ def test_phased_fsim_circuit():
 
 
 @pytest.mark.parametrize('resolve_fn', [cirq.resolve_parameters, cirq.resolve_parameters_once])
-def test_phased_fsim_resolve(resolve_fn):
+def test_phased_fsim_resolve(resolve_fn) -> None:
     f = cirq.PhasedFSimGate(
         sympy.Symbol('a'),
         sympy.Symbol('b'),
@@ -562,7 +562,7 @@ def test_phased_fsim_resolve(resolve_fn):
     assert not cirq.is_parameterized(f)
 
 
-def test_phased_fsim_unitary():
+def test_phased_fsim_unitary() -> None:
     # fmt: off
     np.testing.assert_allclose(
         cirq.unitary(cirq.PhasedFSimGate(theta=0, phi=0)),
@@ -776,13 +776,13 @@ def test_phased_fsim_unitary():
         (3.5 * np.pi, 4 * np.pi),
     ),
 )
-def test_phased_fsim_vs_fsim(theta, phi):
+def test_phased_fsim_vs_fsim(theta, phi) -> None:
     g1 = cirq.FSimGate(theta, phi)
     g2 = cirq.PhasedFSimGate(theta, 0, 0, 0, phi)
     assert np.allclose(cirq.unitary(g1), cirq.unitary(g2))
 
 
-def test_phased_fsim_repr():
+def test_phased_fsim_repr() -> None:
     f = cirq.PhasedFSimGate(
         sympy.Symbol('a'),
         sympy.Symbol('b'),
@@ -793,7 +793,7 @@ def test_phased_fsim_repr():
     cirq.testing.assert_equivalent_repr(f)
 
 
-def test_phased_fsim_json_dict():
+def test_phased_fsim_json_dict() -> None:
     assert cirq.PhasedFSimGate(
         theta=0.12, zeta=0.34, chi=0.56, gamma=0.78, phi=0.9
     )._json_dict_() == {'theta': 0.12, 'zeta': 0.34, 'chi': 0.56, 'gamma': 0.78, 'phi': 0.9}
@@ -811,10 +811,10 @@ def test_phased_fsim_json_dict():
         cirq.CZ**0.2,
     ],
 )
-def test_phase_fsim_from_matrix(gate):
+def test_phase_fsim_from_matrix(gate) -> None:
     u = cirq.unitary(gate)
     np.testing.assert_allclose(cirq.unitary(cirq.PhasedFSimGate.from_matrix(u)), u, atol=1e-8)
 
 
-def test_phase_fsim_from_matrix_not_fsim_returns_none():
+def test_phase_fsim_from_matrix_not_fsim_returns_none() -> None:
     assert cirq.PhasedFSimGate.from_matrix(np.ones((4, 4))) is None

cirq/ops/gate_features.py

@@ -17,6 +17,8 @@
 For example: some gates are reversible, some have known matrices, etc.
 """
 
+from __future__ import annotations
+
 import abc
 
 

cirq/ops/gate_features_test.py

@@ -12,12 +12,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import pytest
 
 import cirq
 
 
-def test_qasm_output_args_validate():
+def test_qasm_output_args_validate() -> None:
     args = cirq.QasmArgs(version='2.0')
     args.validate_version('2.0')
 
@@ -25,7 +27,7 @@ def test_qasm_output_args_validate():
         args.validate_version('2.1')
 
 
-def test_qasm_output_args_format():
+def test_qasm_output_args_format() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
     m_a = cirq.measure(a, key='meas_a')
@@ -52,7 +54,7 @@ def test_qasm_output_args_format():
     assert args.format('_{0}_', 'other') == '_other_'
 
 
-def test_multi_qubit_gate_validate():
+def test_multi_qubit_gate_validate() -> None:
     class Example(cirq.Gate):
         def _num_qubits_(self) -> int:
             return self._num_qubits