cirq-core 1.6.0.dev20250423233500__py3-none-any.whl → 1.6.0.dev20250425004112__py3-none-any.whl

cirq/_version.py

@@ -28,4 +28,4 @@ if sys.version_info < (3, 10, 0):  # pragma: no cover
         'of cirq (e.g. "python -m pip install cirq==1.1.*")'
     )
 
-__version__ = "1.6.0.dev20250423233500"
+__version__ = "1.6.0.dev20250425004112"

cirq/_version_test.py

@@ -3,4 +3,4 @@ import cirq
 
 
 def test_version():
-    assert cirq.__version__ == "1.6.0.dev20250423233500"
+    assert cirq.__version__ == "1.6.0.dev20250425004112"

cirq/ops/dense_pauli_string.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import abc
 import numbers
 from types import NotImplementedType
@@ -45,7 +47,7 @@ if TYPE_CHECKING:
 
 # Order is important! Index equals numeric value.
 PAULI_CHARS = 'IXYZ'
-PAULI_GATES: List[Union['cirq.Pauli', 'cirq.IdentityGate']] = [
+PAULI_GATES: List[Union[cirq.Pauli, cirq.IdentityGate]] = [
     identity.I,
     pauli_gates.X,
     pauli_gates.Y,
@@ -84,9 +86,9 @@ class BaseDensePauliString(raw_types.Gate, metaclass=abc.ABCMeta):
 
     def __init__(
         self,
-        pauli_mask: Union[Iterable['cirq.PAULI_GATE_LIKE'], np.ndarray],
+        pauli_mask: Union[Iterable[cirq.PAULI_GATE_LIKE], np.ndarray],
         *,
-        coefficient: 'cirq.TParamValComplex' = 1,
+        coefficient: cirq.TParamValComplex = 1,
     ):
         """Initializes a new dense pauli string.
 
@@ -116,7 +118,7 @@ class BaseDensePauliString(raw_types.Gate, metaclass=abc.ABCMeta):
         return self._pauli_mask
 
     @property
-    def coefficient(self) -> 'cirq.TParamValComplex':
+    def coefficient(self) -> cirq.TParamValComplex:
         """A complex coefficient or symbol."""
         return self._coefficient
 
@@ -129,7 +131,7 @@ class BaseDensePauliString(raw_types.Gate, metaclass=abc.ABCMeta):
         return self.coefficient, tuple(PAULI_CHARS[p] for p in self.pauli_mask)
 
     @classmethod
-    def one_hot(cls, *, index: int, length: int, pauli: 'cirq.PAULI_GATE_LIKE') -> Self:
+    def one_hot(cls, *, index: int, length: int, pauli: cirq.PAULI_GATE_LIKE) -> Self:
         """Creates a dense pauli string with only one non-identity Pauli.
 
         Args:
@@ -179,9 +181,7 @@ class BaseDensePauliString(raw_types.Gate, metaclass=abc.ABCMeta):
         decomposed_ops = cast(Iterable['cirq.OP_TREE'], self._decompose_(qubits))
         return protocols.apply_unitaries(decomposed_ops, qubits, args)
 
-    def _decompose_(
-        self, qubits: Sequence['cirq.Qid']
-    ) -> Union[NotImplementedType, 'cirq.OP_TREE']:
+    def _decompose_(self, qubits: Sequence[cirq.Qid]) -> Union[NotImplementedType, cirq.OP_TREE]:
         if not self._has_unitary_():
             return NotImplemented
         result = [PAULI_GATES[p].on(q) for p, q in zip(self.pauli_mask, qubits) if p]
@@ -195,7 +195,7 @@ class BaseDensePauliString(raw_types.Gate, metaclass=abc.ABCMeta):
     def _parameter_names_(self) -> AbstractSet[str]:
         return protocols.parameter_names(self.coefficient)
 
-    def _resolve_parameters_(self, resolver: 'cirq.ParamResolver', recursive: bool) -> Self:
+    def _resolve_parameters_(self, resolver: cirq.ParamResolver, recursive: bool) -> Self:
         return self.copy(
             coefficient=protocols.resolve_parameters(self.coefficient, resolver, recursive)
         )
@@ -218,7 +218,7 @@ class BaseDensePauliString(raw_types.Gate, metaclass=abc.ABCMeta):
         return NotImplemented
 
     @overload
-    def __getitem__(self, item: int) -> Union['cirq.Pauli', 'cirq.IdentityGate']:
+    def __getitem__(self, item: int) -> Union[cirq.Pauli, cirq.IdentityGate]:
         pass
 
     @overload
@@ -234,7 +234,7 @@ class BaseDensePauliString(raw_types.Gate, metaclass=abc.ABCMeta):
 
         raise TypeError(f'indices must be integers or slices, not {type(item)}')
 
-    def __iter__(self) -> Iterator[Union['cirq.Pauli', 'cirq.IdentityGate']]:
+    def __iter__(self) -> Iterator[Union[cirq.Pauli, cirq.IdentityGate]]:
         for i in range(len(self)):
             yield self[i]
 
@@ -301,7 +301,7 @@ class BaseDensePauliString(raw_types.Gate, metaclass=abc.ABCMeta):
 
         return NotImplemented
 
-    def tensor_product(self, other: 'BaseDensePauliString') -> Self:
+    def tensor_product(self, other: BaseDensePauliString) -> Self:
         """Concatenates dense pauli strings and multiplies their coefficients.
 
         Args:
@@ -323,10 +323,10 @@ class BaseDensePauliString(raw_types.Gate, metaclass=abc.ABCMeta):
             pauli_mask=self.pauli_mask,
         )
 
-    def on(self, *qubits: 'cirq.Qid') -> 'cirq.PauliString':
+    def on(self, *qubits: cirq.Qid) -> cirq.PauliString:
         return self.sparse(qubits)
 
-    def sparse(self, qubits: Optional[Sequence['cirq.Qid']] = None) -> 'cirq.PauliString':
+    def sparse(self, qubits: Optional[Sequence[cirq.Qid]] = None) -> cirq.PauliString:
         """A `cirq.PauliString` version of this dense pauli string.
 
         Args:
@@ -390,11 +390,11 @@ class BaseDensePauliString(raw_types.Gate, metaclass=abc.ABCMeta):
 
         return NotImplemented
 
-    def frozen(self) -> 'DensePauliString':
+    def frozen(self) -> DensePauliString:
         """A `cirq.DensePauliString` with the same contents."""
         return DensePauliString(coefficient=self.coefficient, pauli_mask=self.pauli_mask)
 
-    def mutable_copy(self) -> 'MutableDensePauliString':
+    def mutable_copy(self) -> MutableDensePauliString:
         """A `cirq.MutableDensePauliString` with the same contents."""
         return MutableDensePauliString(
             coefficient=self.coefficient, pauli_mask=np.copy(self.pauli_mask)
@@ -403,7 +403,7 @@ class BaseDensePauliString(raw_types.Gate, metaclass=abc.ABCMeta):
     @abc.abstractmethod
     def copy(
         self,
-        coefficient: Optional['cirq.TParamValComplex'] = None,
+        coefficient: Optional[cirq.TParamValComplex] = None,
         pauli_mask: Union[None, str, Iterable[int], np.ndarray] = None,
     ) -> Self:
         """Returns a copy with possibly modified contents.
@@ -454,14 +454,14 @@ class DensePauliString(BaseDensePauliString):
     dense pauli strings, see `cirq.MutableDensePauliString`.
     """
 
-    def frozen(self) -> 'DensePauliString':
+    def frozen(self) -> DensePauliString:
         return self
 
     def copy(
         self,
-        coefficient: Optional['cirq.TParamValComplex'] = None,
+        coefficient: Optional[cirq.TParamValComplex] = None,
         pauli_mask: Union[None, str, Iterable[int], np.ndarray] = None,
-    ) -> 'DensePauliString':
+    ) -> DensePauliString:
         if pauli_mask is None and (coefficient is None or coefficient == self.coefficient):
             return self
         return DensePauliString(
@@ -489,14 +489,14 @@ class MutableDensePauliString(BaseDensePauliString):
     """
 
     @overload
-    def __setitem__(self, key: int, value: 'cirq.PAULI_GATE_LIKE') -> Self:
+    def __setitem__(self, key: int, value: cirq.PAULI_GATE_LIKE) -> Self:
         pass
 
     @overload
     def __setitem__(
         self,
         key: slice,
-        value: Union[Iterable['cirq.PAULI_GATE_LIKE'], np.ndarray, BaseDensePauliString],
+        value: Union[Iterable[cirq.PAULI_GATE_LIKE], np.ndarray, BaseDensePauliString],
     ) -> Self:
         pass
 
@@ -559,9 +559,9 @@ class MutableDensePauliString(BaseDensePauliString):
 
     def copy(
         self,
-        coefficient: Optional['cirq.TParamValComplex'] = None,
+        coefficient: Optional[cirq.TParamValComplex] = None,
         pauli_mask: Union[None, str, Iterable[int], np.ndarray] = None,
-    ) -> 'MutableDensePauliString':
+    ) -> MutableDensePauliString:
         return MutableDensePauliString(
             coefficient=self.coefficient if coefficient is None else coefficient,
             pauli_mask=np.copy(self.pauli_mask) if pauli_mask is None else pauli_mask,
@@ -574,7 +574,7 @@ class MutableDensePauliString(BaseDensePauliString):
         return self.coefficient, tuple(PAULI_CHARS[p] for p in self.pauli_mask)
 
     @classmethod
-    def inline_gaussian_elimination(cls, rows: 'List[MutableDensePauliString]') -> None:
+    def inline_gaussian_elimination(cls, rows: List[MutableDensePauliString]) -> None:
         if not rows:
             return
 
@@ -605,7 +605,7 @@ class MutableDensePauliString(BaseDensePauliString):
                 next_row += 1
 
 
-def _pauli_index(val: 'cirq.PAULI_GATE_LIKE') -> int:
+def _pauli_index(val: cirq.PAULI_GATE_LIKE) -> int:
     m = pauli_string.PAULI_GATE_LIKE_TO_INDEX_MAP
     if val not in m:
         raise TypeError(
@@ -616,13 +616,13 @@ def _pauli_index(val: 'cirq.PAULI_GATE_LIKE') -> int:
     return m[val]
 
 
-def _as_pauli_mask(val: Union[Iterable['cirq.PAULI_GATE_LIKE'], np.ndarray]) -> np.ndarray:
+def _as_pauli_mask(val: Union[Iterable[cirq.PAULI_GATE_LIKE], np.ndarray]) -> np.ndarray:
     if isinstance(val, np.ndarray):
         return np.asarray(val, dtype=np.uint8)
     return np.array([_pauli_index(v) for v in val], dtype=np.uint8)
 
 
-def _attempt_value_to_pauli_index(v: 'cirq.Operation') -> Optional[Tuple[int, int]]:
+def _attempt_value_to_pauli_index(v: cirq.Operation) -> Optional[Tuple[int, int]]:
     if not isinstance(v, raw_types.Operation):
         return None
 

cirq/ops/diagonal_gate.py

@@ -18,6 +18,8 @@ The gate is used to create a (2^n)x(2^n) matrix with the diagonal elements
 passed as a list.
 """
 
+from __future__ import annotations
+
 from typing import (
     AbstractSet,
     Any,
@@ -81,7 +83,7 @@ class DiagonalGate(raw_types.Gate):
     all phases.
     """
 
-    def __init__(self, diag_angles_radians: Sequence['cirq.TParamVal']) -> None:
+    def __init__(self, diag_angles_radians: Sequence[cirq.TParamVal]) -> None:
         r"""A n-qubit gate with only diagonal elements.
 
         This gate's off-diagonal elements are zero and its on-diagonal
@@ -92,10 +94,10 @@ class DiagonalGate(raw_types.Gate):
                 If these values are $(x_0, x_1, \ldots , x_N)$ then the unitary
                 has diagonal values $(e^{i x_0}, e^{i x_1}, \ldots, e^{i x_N})$.
         """
-        self._diag_angles_radians: Tuple['cirq.TParamVal', ...] = tuple(diag_angles_radians)
+        self._diag_angles_radians: Tuple[cirq.TParamVal, ...] = tuple(diag_angles_radians)
 
     @property
-    def diag_angles_radians(self) -> Tuple['cirq.TParamVal', ...]:
+    def diag_angles_radians(self) -> Tuple[cirq.TParamVal, ...]:
         return self._diag_angles_radians
 
     def _num_qubits_(self):
@@ -109,9 +111,7 @@ class DiagonalGate(raw_types.Gate):
             name for angle in self._diag_angles_radians for name in protocols.parameter_names(angle)
         }
 
-    def _resolve_parameters_(
-        self, resolver: 'cirq.ParamResolver', recursive: bool
-    ) -> 'DiagonalGate':
+    def _resolve_parameters_(self, resolver: cirq.ParamResolver, recursive: bool) -> DiagonalGate:
         return DiagonalGate(
             protocols.resolve_parameters(self._diag_angles_radians, resolver, recursive)
         )
@@ -124,7 +124,7 @@ class DiagonalGate(raw_types.Gate):
             return None
         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):
@@ -132,9 +132,7 @@ class DiagonalGate(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)
@@ -150,7 +148,7 @@ class DiagonalGate(raw_types.Gate):
             [diag_str] + [f"#{i}" for i in range(2, self._num_qubits_() + 1)]
         )
 
-    def __pow__(self, exponent: Any) -> 'DiagonalGate':
+    def __pow__(self, exponent: Any) -> DiagonalGate:
         if not isinstance(exponent, (int, float, sympy.Basic)):
             return NotImplemented
         angles = []
@@ -163,8 +161,8 @@ class DiagonalGate(raw_types.Gate):
         return tuple(self._diag_angles_radians)
 
     def _decompose_for_basis(
-        self, index: int, bit_flip: int, theta: 'cirq.TParamVal', qubits: Sequence['cirq.Qid']
-    ) -> Iterator[Union['cirq.ZPowGate', 'cirq.CXPowGate']]:
+        self, index: int, bit_flip: int, theta: cirq.TParamVal, qubits: Sequence[cirq.Qid]
+    ) -> Iterator[Union[cirq.ZPowGate, cirq.CXPowGate]]:
         if index == 0:
             return
         largest_digit = self._num_qubits_() - (len(bin(index)) - 2)
@@ -175,7 +173,7 @@ class DiagonalGate(raw_types.Gate):
         elif _flip_bit > largest_digit:
             yield common_gates.CNOT(qubits[_flip_bit], qubits[largest_digit])
 
-    def _decompose_(self, qubits: Sequence['cirq.Qid']) -> 'cirq.OP_TREE':
+    def _decompose_(self, qubits: Sequence[cirq.Qid]) -> cirq.OP_TREE:
         """Decompose the n-qubit diagonal gates into CNOT and Rz gates.
 
         A 3 qubits decomposition looks like

cirq/ops/eigen_gate.py

@@ -11,6 +11,9 @@
 # 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
@@ -131,7 +134,7 @@ 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__
@@ -144,7 +147,7 @@ class EigenGate(raw_types.Gate):
         # 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 +202,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.
 
@@ -297,7 +300,7 @@ 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: Union[float, sympy.Symbol]) -> EigenGate:
         new_exponent = protocols.mul(self._exponent, exponent, NotImplemented)
         if new_exponent is NotImplemented:
             return NotImplemented  # pragma: no cover
@@ -344,7 +347,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):

cirq/ops/fourier_transform.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 from typing import AbstractSet, Any, Dict, Union
 
 import numpy as np
@@ -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,
@@ -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

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,6 +22,8 @@ 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
@@ -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:
@@ -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) -> Optional[np.ndarray]:
         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:
@@ -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) -> Optional[PhasedFSimGate]:
         """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
@@ -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) -> Optional[np.ndarray]:
         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)