cirq-core 1.6.0.dev20250424231143__py3-none-any.whl → 1.6.0.dev20250428201230__py3-none-any.whl

cirq/ops/pauli_string.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 cmath
 import math
 import numbers
@@ -159,9 +162,9 @@ class PauliString(raw_types.Operation, Generic[TKey]):
 
     def __init__(
         self,
-        *contents: 'cirq.PAULI_STRING_LIKE',
-        qubit_pauli_map: Optional[Dict[TKey, 'cirq.Pauli']] = None,
-        coefficient: 'cirq.TParamValComplex' = 1,
+        *contents: cirq.PAULI_STRING_LIKE,
+        qubit_pauli_map: Optional[Dict[TKey, cirq.Pauli]] = None,
+        coefficient: cirq.TParamValComplex = 1,
     ):
         """Initializes a new `PauliString` operation.
 
@@ -188,8 +191,8 @@ class PauliString(raw_types.Operation, Generic[TKey]):
                 if not isinstance(v, pauli_gates.Pauli):
                     raise TypeError(f'{v} is not a Pauli')
 
-        self._qubit_pauli_map: Dict[TKey, 'cirq.Pauli'] = qubit_pauli_map or {}
-        self._coefficient: Union['cirq.TParamValComplex', sympy.Expr] = (
+        self._qubit_pauli_map: Dict[TKey, cirq.Pauli] = qubit_pauli_map or {}
+        self._coefficient: Union[cirq.TParamValComplex, sympy.Expr] = (
             coefficient if isinstance(coefficient, sympy.Expr) else complex(coefficient)
         )
         if contents:
@@ -198,7 +201,7 @@ class PauliString(raw_types.Operation, Generic[TKey]):
             self._coefficient = m._coefficient
 
     @property
-    def coefficient(self) -> 'cirq.TParamValComplex':
+    def coefficient(self) -> cirq.TParamValComplex:
         """A scalar coefficient or symbol."""
         return self._coefficient
 
@@ -225,7 +228,7 @@ class PauliString(raw_types.Operation, Generic[TKey]):
             return gate_operation.GateOperation
         return PauliString
 
-    def equal_up_to_coefficient(self, other: 'cirq.PauliString') -> bool:
+    def equal_up_to_coefficient(self, other: cirq.PauliString) -> bool:
         """Returns true of `self` and `other` are equal pauli strings, ignoring the coefficient."""
         return self._qubit_pauli_map == other._qubit_pauli_map
 
@@ -249,28 +252,28 @@ class PauliString(raw_types.Operation, Generic[TKey]):
 
     @overload
     def __mul__(
-        self, other: 'cirq.PauliString[TKeyOther]'
-    ) -> 'cirq.PauliString[Union[TKey, TKeyOther]]':
+        self, other: cirq.PauliString[TKeyOther]
+    ) -> cirq.PauliString[Union[TKey, TKeyOther]]:
         pass
 
     @overload
     def __mul__(
-        self, other: Mapping[TKeyOther, 'cirq.PAULI_GATE_LIKE']
-    ) -> 'cirq.PauliString[Union[TKey, TKeyOther]]':
+        self, other: Mapping[TKeyOther, cirq.PAULI_GATE_LIKE]
+    ) -> cirq.PauliString[Union[TKey, TKeyOther]]:
         pass
 
     @overload
     def __mul__(
-        self, other: Iterable['cirq.PAULI_STRING_LIKE']
-    ) -> 'cirq.PauliString[Union[TKey, cirq.Qid]]':
+        self, other: Iterable[cirq.PAULI_STRING_LIKE]
+    ) -> cirq.PauliString[Union[TKey, cirq.Qid]]:
         pass
 
     @overload
-    def __mul__(self, other: 'cirq.Operation') -> 'cirq.PauliString[Union[TKey, cirq.Qid]]':
+    def __mul__(self, other: cirq.Operation) -> cirq.PauliString[Union[TKey, cirq.Qid]]:
         pass
 
     @overload
-    def __mul__(self, other: complex) -> 'cirq.PauliString[TKey]':
+    def __mul__(self, other: complex) -> cirq.PauliString[TKey]:
         pass
 
     def __mul__(self, other):
@@ -290,7 +293,7 @@ class PauliString(raw_types.Operation, Generic[TKey]):
     # pylint: enable=function-redefined
 
     @property
-    def gate(self) -> 'cirq.DensePauliString':
+    def gate(self) -> cirq.DensePauliString:
         """Returns a `cirq.DensePauliString`"""
         order: List[Optional[pauli_gates.Pauli]] = [
             None,
@@ -304,7 +307,7 @@ class PauliString(raw_types.Operation, Generic[TKey]):
             coefficient=self.coefficient, pauli_mask=[order.index(self[q]) for q in self.qubits]
         )
 
-    def __rmul__(self, other) -> 'PauliString':
+    def __rmul__(self, other) -> PauliString:
         if isinstance(other, numbers.Complex):
             return PauliString(
                 qubit_pauli_map=self._qubit_pauli_map, coefficient=self._coefficient * other
@@ -359,7 +362,7 @@ class PauliString(raw_types.Operation, Generic[TKey]):
         """Returns a tuple of qubits on which this pauli string acts."""
         return tuple(self.keys())
 
-    def _circuit_diagram_info_(self, args: 'cirq.CircuitDiagramInfoArgs') -> List[str]:
+    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> List[str]:
         if not len(self._qubit_pauli_map):
             return NotImplemented
 
@@ -380,7 +383,7 @@ class PauliString(raw_types.Operation, Generic[TKey]):
         symbols[0] = f'PauliString({prefix}{symbols[0]})'
         return symbols
 
-    def with_qubits(self, *new_qubits: 'cirq.Qid') -> 'PauliString':
+    def with_qubits(self, *new_qubits: cirq.Qid) -> PauliString:
         """Returns a new `PauliString` with `self.qubits` mapped to `new_qubits`.
 
         Args:
@@ -402,7 +405,7 @@ class PauliString(raw_types.Operation, Generic[TKey]):
             coefficient=self._coefficient,
         )
 
-    def with_coefficient(self, new_coefficient: 'cirq.TParamValComplex') -> 'PauliString':
+    def with_coefficient(self, new_coefficient: cirq.TParamValComplex) -> PauliString:
         """Returns a new `PauliString` with `self.coefficient` replaced with `new_coefficient`."""
         return PauliString(qubit_pauli_map=dict(self._qubit_pauli_map), coefficient=new_coefficient)
 
@@ -414,11 +417,11 @@ class PauliString(raw_types.Operation, Generic[TKey]):
         """Returns (cirq.Qid, cirq.Pauli) pairs representing 1-qubit operations of pauli string."""
         return self._qubit_pauli_map.items()
 
-    def frozen(self) -> 'cirq.PauliString':
+    def frozen(self) -> cirq.PauliString:
         """Returns a `cirq.PauliString` with the same contents."""
         return self
 
-    def mutable_copy(self) -> 'cirq.MutablePauliString':
+    def mutable_copy(self) -> cirq.MutablePauliString:
         """Returns a new `cirq.MutablePauliString` with the same contents."""
         return MutablePauliString(
             coefficient=self.coefficient,
@@ -510,7 +513,7 @@ class PauliString(raw_types.Operation, Generic[TKey]):
             return None
         return self.matrix()
 
-    def _apply_unitary_(self, args: 'protocols.ApplyUnitaryArgs'):
+    def _apply_unitary_(self, args: protocols.ApplyUnitaryArgs):
         if not self._has_unitary_():
             return None
         assert isinstance(self.coefficient, numbers.Complex)
@@ -738,7 +741,7 @@ class PauliString(raw_types.Operation, Generic[TKey]):
         return float(np.real(result * self.coefficient))
 
     def zip_items(
-        self, other: 'cirq.PauliString[TKey]'
+        self, other: cirq.PauliString[TKey]
     ) -> Iterator[Tuple[TKey, Tuple[pauli_gates.Pauli, pauli_gates.Pauli]]]:
         """Combines pauli operations from pauli strings in a qubit-by-qubit fashion.
 
@@ -757,7 +760,7 @@ class PauliString(raw_types.Operation, Generic[TKey]):
                 yield qubit, (pauli0, other[qubit])
 
     def zip_paulis(
-        self, other: 'cirq.PauliString'
+        self, other: cirq.PauliString
     ) -> Iterator[Tuple[pauli_gates.Pauli, pauli_gates.Pauli]]:
         """Combines pauli operations from pauli strings in a qubit-by-qubit fashion.
 
@@ -780,10 +783,10 @@ class PauliString(raw_types.Operation, Generic[TKey]):
             return NotImplemented
         return sum(not protocols.commutes(p0, p1) for p0, p1 in self.zip_paulis(other)) % 2 == 0
 
-    def __neg__(self) -> 'PauliString':
+    def __neg__(self) -> PauliString:
         return PauliString(qubit_pauli_map=self._qubit_pauli_map, coefficient=-self._coefficient)
 
-    def __pos__(self) -> 'PauliString':
+    def __pos__(self) -> PauliString:
         return self
 
     def __array_ufunc__(self, ufunc, method, *inputs, **kwargs):
@@ -861,7 +864,7 @@ class PauliString(raw_types.Operation, Generic[TKey]):
             )
         return NotImplemented
 
-    def map_qubits(self, qubit_map: Dict[TKey, TKeyNew]) -> 'cirq.PauliString[TKeyNew]':
+    def map_qubits(self, qubit_map: Dict[TKey, TKeyNew]) -> cirq.PauliString[TKeyNew]:
         """Replaces every qubit `q` in `self.qubits` with `qubit_map[q]`.
 
         Args:
@@ -888,7 +891,7 @@ class PauliString(raw_types.Operation, Generic[TKey]):
                 {pauli: (pauli_gates.Z, False)}
             )(qubit)
 
-    def dense(self, qubits: Sequence[TKey]) -> 'cirq.DensePauliString':
+    def dense(self, qubits: Sequence[TKey]) -> cirq.DensePauliString:
         """Returns a `cirq.DensePauliString` version of this Pauli string.
 
         This method satisfies the invariant `P.dense(qubits).on(*qubits) == P`.
@@ -915,7 +918,7 @@ class PauliString(raw_types.Operation, Generic[TKey]):
         # pylint: enable=too-many-function-args
         return dense_pauli_string.DensePauliString(pauli_mask, coefficient=self.coefficient)
 
-    def conjugated_by(self, clifford: 'cirq.OP_TREE') -> 'PauliString':
+    def conjugated_by(self, clifford: cirq.OP_TREE) -> PauliString:
         r"""Returns the Pauli string conjugated by a clifford operation.
 
         The product-of-Paulis $P$ conjugated by the Clifford operation $C$ is
@@ -987,12 +990,12 @@ class PauliString(raw_types.Operation, Generic[TKey]):
             # Then the conjugation = (C^{-1}⊗I·Pc⊗R·C⊗I) = (C^{-1}·Pc·C)⊗R.
 
             # Isolate R
-            remain: 'cirq.PauliString' = PauliString(
+            remain: cirq.PauliString = PauliString(
                 *(pauli(q) for q in all_qubits - set(op.qubits) if (pauli := ps.get(q)) is not None)
             )
 
             # Initialize the conjugation of Pc.
-            conjugated: 'cirq.DensePauliString' = (
+            conjugated: cirq.DensePauliString = (
                 dense_pauli_string.DensePauliString(pauli_mask=[identity.I for _ in op.qubits])
                 * ps.coefficient
             )
@@ -1000,7 +1003,7 @@ class PauliString(raw_types.Operation, Generic[TKey]):
             # Calculate the conjugation via CliffordGate's clifford_tableau.
             # Note the clifford_tableau in CliffordGate represents C·P·C^-1 instead of C^-1·P·C.
             # So we take the inverse of the tableau to match the definition of the conjugation here.
-            gate_in_clifford: 'cirq.CliffordGate'
+            gate_in_clifford: cirq.CliffordGate
             if isinstance(op.gate, clifford_gate.CliffordGate):
                 gate_in_clifford = op.gate
             else:
@@ -1035,7 +1038,7 @@ class PauliString(raw_types.Operation, Generic[TKey]):
             ps = remain * conjugated.on(*op.qubits)
         return ps
 
-    def after(self, ops: 'cirq.OP_TREE') -> 'cirq.PauliString':
+    def after(self, ops: cirq.OP_TREE) -> cirq.PauliString:
         r"""Determines the equivalent pauli string after some operations.
 
         If the PauliString is $P$ and the Clifford operation is $C$, then the
@@ -1051,7 +1054,7 @@ class PauliString(raw_types.Operation, Generic[TKey]):
         """
         return self.conjugated_by(protocols.inverse(ops))
 
-    def before(self, ops: 'cirq.OP_TREE') -> 'cirq.PauliString':
+    def before(self, ops: cirq.OP_TREE) -> cirq.PauliString:
         r"""Determines the equivalent pauli string before some operations.
 
         If the PauliString is $P$ and the Clifford operation is $C$, then the
@@ -1068,8 +1071,8 @@ class PauliString(raw_types.Operation, Generic[TKey]):
         return self.conjugated_by(ops)
 
     def pass_operations_over(
-        self, ops: Iterable['cirq.Operation'], after_to_before: bool = False
-    ) -> 'PauliString':
+        self, ops: Iterable[cirq.Operation], after_to_before: bool = False
+    ) -> PauliString:
         """Determines how the Pauli string changes when conjugated by Cliffords.
 
         The output and input pauli strings are related by a circuit equivalence.
@@ -1115,8 +1118,8 @@ class PauliString(raw_types.Operation, Generic[TKey]):
         return protocols.parameter_names(self.coefficient)
 
     def _resolve_parameters_(
-        self, resolver: 'cirq.ParamResolver', recursive: bool
-    ) -> 'cirq.PauliString':
+        self, resolver: cirq.ParamResolver, recursive: bool
+    ) -> cirq.PauliString:
         coefficient = protocols.resolve_parameters(self.coefficient, resolver, recursive)
         return PauliString(qubit_pauli_map=self._qubit_pauli_map, coefficient=coefficient)
 
@@ -1189,11 +1192,11 @@ class SingleQubitPauliStringGateOperation(  # type: ignore
     GateOperation(X, [q]).
     """
 
-    def __init__(self, pauli: pauli_gates.Pauli, qubit: 'cirq.Qid'):
+    def __init__(self, pauli: pauli_gates.Pauli, qubit: cirq.Qid):
         PauliString.__init__(self, qubit_pauli_map={qubit: pauli})
         gate_operation.GateOperation.__init__(self, cast(raw_types.Gate, pauli), [qubit])
 
-    def with_qubits(self, *new_qubits: 'cirq.Qid') -> 'SingleQubitPauliStringGateOperation':
+    def with_qubits(self, *new_qubits: cirq.Qid) -> SingleQubitPauliStringGateOperation:
         if len(new_qubits) != 1:
             raise ValueError("len(new_qubits) != 1")
         return SingleQubitPauliStringGateOperation(
@@ -1235,9 +1238,7 @@ class SingleQubitPauliStringGateOperation(  # type: ignore
         return protocols.obj_to_dict_helper(self, ['pauli', 'qubit'])
 
     @classmethod
-    def _from_json_dict_(  # type: ignore
-        cls, pauli: pauli_gates.Pauli, qubit: 'cirq.Qid', **kwargs
-    ):
+    def _from_json_dict_(cls, pauli: pauli_gates.Pauli, qubit: cirq.Qid, **kwargs):  # type: ignore
         # Note, this method is required or else superclasses' deserialization
         # would be used
         return cls(pauli=pauli, qubit=qubit)
@@ -1258,8 +1259,8 @@ class MutablePauliString(Generic[TKey]):
 
     def __init__(
         self,
-        *contents: 'cirq.PAULI_STRING_LIKE',
-        coefficient: 'cirq.TParamValComplex' = 1,
+        *contents: cirq.PAULI_STRING_LIKE,
+        coefficient: cirq.TParamValComplex = 1,
         pauli_int_dict: Optional[Dict[TKey, int]] = None,
     ):
         """Initializes a new `MutablePauliString`.
@@ -1282,7 +1283,7 @@ class MutablePauliString(Generic[TKey]):
         Raises:
             ValueError: If the `pauli_int_dict` has integer values `v` not satisfying `1 <= v <= 3`.
         """
-        self.coefficient: Union[sympy.Expr, 'cirq.TParamValComplex'] = (
+        self.coefficient: Union[sympy.Expr, cirq.TParamValComplex] = (
             coefficient if isinstance(coefficient, sympy.Expr) else complex(coefficient)
         )
         if pauli_int_dict is not None:
@@ -1314,7 +1315,7 @@ class MutablePauliString(Generic[TKey]):
         """Returns the sequence of qubits on which this pauli string acts."""
         return self.pauli_int_dict.keys()
 
-    def values(self) -> Iterator['cirq.Pauli']:
+    def values(self) -> Iterator[cirq.Pauli]:
         """Ordered sequence of `cirq.Pauli` gates acting on `self.keys()`."""
         for v in self.pauli_int_dict.values():
             yield _INT_TO_PAULI[v - 1]
@@ -1328,7 +1329,7 @@ class MutablePauliString(Generic[TKey]):
     def __bool__(self) -> bool:
         return bool(self.pauli_int_dict)
 
-    def frozen(self) -> 'cirq.PauliString':
+    def frozen(self) -> cirq.PauliString:
         """Returns a `cirq.PauliString` with the same contents.
 
         For example, this is useful because `cirq.PauliString` is an operation
@@ -1339,13 +1340,13 @@ class MutablePauliString(Generic[TKey]):
             qubit_pauli_map={q: _INT_TO_PAULI[p - 1] for q, p in self.pauli_int_dict.items() if p},
         )
 
-    def mutable_copy(self) -> 'cirq.MutablePauliString':
+    def mutable_copy(self) -> cirq.MutablePauliString:
         """Returns a new `cirq.MutablePauliString` with the same contents."""
         return MutablePauliString(
             coefficient=self.coefficient, pauli_int_dict=dict(self.pauli_int_dict)
         )
 
-    def items(self) -> Iterator[Tuple[TKey, 'cirq.Pauli']]:
+    def items(self) -> Iterator[Tuple[TKey, cirq.Pauli]]:
         """Returns (cirq.Qid, cirq.Pauli) pairs representing 1-qubit operations of pauli string."""
         for k, v in self.pauli_int_dict.items():
             yield k, _INT_TO_PAULI[v - 1]
@@ -1353,10 +1354,10 @@ class MutablePauliString(Generic[TKey]):
     def __contains__(self, item: Any) -> bool:
         return item in self.pauli_int_dict
 
-    def __getitem__(self, item: Any) -> 'cirq.Pauli':
+    def __getitem__(self, item: Any) -> cirq.Pauli:
         return _INT_TO_PAULI[self.pauli_int_dict[item] - 1]
 
-    def __setitem__(self, key: TKey, value: 'cirq.PAULI_GATE_LIKE'):
+    def __setitem__(self, key: TKey, value: cirq.PAULI_GATE_LIKE):
         value = _pauli_like_to_pauli_int(key, value)
         if value:
             self.pauli_int_dict[key] = _pauli_like_to_pauli_int(key, value)
@@ -1368,20 +1369,20 @@ class MutablePauliString(Generic[TKey]):
 
     # pylint: disable=function-redefined
     @overload
-    def get(self, key: TKey, default: None = None) -> Union['cirq.Pauli', None]:
+    def get(self, key: TKey, default: None = None) -> Union[cirq.Pauli, None]:
         pass
 
     @overload
-    def get(self, key: TKey, default: TDefault) -> Union['cirq.Pauli', TDefault]:
+    def get(self, key: TKey, default: TDefault) -> Union[cirq.Pauli, TDefault]:
         pass
 
-    def get(self, key: TKey, default=None) -> Union['cirq.Pauli', TDefault, None]:
+    def get(self, key: TKey, default=None) -> Union[cirq.Pauli, TDefault, None]:
         """Returns the `cirq.Pauli` operation acting on qubit `key` or `default` if none exists."""
         result = self.pauli_int_dict.get(key, None)
         return default if result is None else _INT_TO_PAULI[result - 1]
 
     # pylint: enable=function-redefined
-    def inplace_before(self, ops: 'cirq.OP_TREE') -> 'cirq.MutablePauliString':
+    def inplace_before(self, ops: cirq.OP_TREE) -> cirq.MutablePauliString:
         r"""Propagates the pauli string from after to before a Clifford effect.
 
         If the old value of the MutablePauliString is $P$ and the Clifford
@@ -1397,7 +1398,7 @@ class MutablePauliString(Generic[TKey]):
         """
         return self.inplace_after(protocols.inverse(ops))
 
-    def inplace_after(self, ops: 'cirq.OP_TREE') -> 'cirq.MutablePauliString':
+    def inplace_after(self, ops: cirq.OP_TREE) -> cirq.MutablePauliString:
         r"""Propagates the pauli string from before to after a Clifford effect.
 
         If the old value of the MutablePauliString is $P$ and the Clifford
@@ -1453,7 +1454,7 @@ class MutablePauliString(Generic[TKey]):
                     raise NotImplementedError(f"Unrecognized decomposed Clifford: {op!r}")
         return self
 
-    def _imul_helper(self, other: 'cirq.PAULI_STRING_LIKE', sign: int):
+    def _imul_helper(self, other: cirq.PAULI_STRING_LIKE, sign: int):
         """Left-multiplies or right-multiplies by a PAULI_STRING_LIKE.
 
         Args:
@@ -1492,7 +1493,7 @@ class MutablePauliString(Generic[TKey]):
 
         return self
 
-    def _imul_helper_checkpoint(self, other: 'cirq.PAULI_STRING_LIKE', sign: int):
+    def _imul_helper_checkpoint(self, other: cirq.PAULI_STRING_LIKE, sign: int):
         """Like `_imul_helper` but guarantees no-op on error."""
 
         if not isinstance(other, (numbers.Number, PauliString, MutablePauliString)):
@@ -1501,9 +1502,7 @@ class MutablePauliString(Generic[TKey]):
                 return NotImplemented
         return self._imul_helper(other, sign)
 
-    def inplace_left_multiply_by(
-        self, other: 'cirq.PAULI_STRING_LIKE'
-    ) -> 'cirq.MutablePauliString':
+    def inplace_left_multiply_by(self, other: cirq.PAULI_STRING_LIKE) -> cirq.MutablePauliString:
         """Left-multiplies a pauli string into this pauli string.
 
         Args:
@@ -1532,9 +1531,7 @@ class MutablePauliString(Generic[TKey]):
     def _from_json_dict_(cls, pauli_int_dict, coefficient, **kwargs):
         return cls(pauli_int_dict=dict(pauli_int_dict), coefficient=coefficient)
 
-    def inplace_right_multiply_by(
-        self, other: 'cirq.PAULI_STRING_LIKE'
-    ) -> 'cirq.MutablePauliString':
+    def inplace_right_multiply_by(self, other: cirq.PAULI_STRING_LIKE) -> cirq.MutablePauliString:
         """Right-multiplies a pauli string into this pauli string.
 
         Args:
@@ -1552,17 +1549,17 @@ class MutablePauliString(Generic[TKey]):
             raise TypeError(f"{other!r} is not cirq.PAULI_STRING_LIKE.")
         return self
 
-    def __neg__(self) -> 'cirq.MutablePauliString':
+    def __neg__(self) -> cirq.MutablePauliString:
         result = self.mutable_copy()
         result.coefficient *= -1
         return result
 
-    def __pos__(self) -> 'cirq.MutablePauliString':
+    def __pos__(self) -> cirq.MutablePauliString:
         return self.mutable_copy()
 
     def transform_qubits(
         self, func: Callable[[TKey], TKeyNew], *, inplace: bool = False
-    ) -> 'cirq.MutablePauliString[TKeyNew]':
+    ) -> cirq.MutablePauliString[TKeyNew]:
         """Returns a `MutablePauliString` with transformed qubits.
 
         Args:
@@ -1585,7 +1582,7 @@ class MutablePauliString(Generic[TKey]):
         result.pauli_int_dict = new_dict
         return result
 
-    def __imul__(self, other: 'cirq.PAULI_STRING_LIKE') -> 'cirq.MutablePauliString':
+    def __imul__(self, other: cirq.PAULI_STRING_LIKE) -> cirq.MutablePauliString:
         """Left-multiplies a pauli string into this pauli string.
 
         Args:
@@ -1601,14 +1598,14 @@ class MutablePauliString(Generic[TKey]):
         """
         return self._imul_helper_checkpoint(other, +1)
 
-    def __mul__(self, other: 'cirq.PAULI_STRING_LIKE') -> 'cirq.PauliString':
+    def __mul__(self, other: cirq.PAULI_STRING_LIKE) -> cirq.PauliString:
         """Multiplies two pauli-string-likes together.
 
         The result is not mutable.
         """
         return self.frozen() * other
 
-    def __rmul__(self, other: 'cirq.PAULI_STRING_LIKE') -> 'cirq.PauliString':
+    def __rmul__(self, other: cirq.PAULI_STRING_LIKE) -> cirq.PauliString:
         """Multiplies two pauli-string-likes together.
 
         The result is not mutable.
@@ -1622,7 +1619,7 @@ class MutablePauliString(Generic[TKey]):
         return f'{self.frozen()!r}.mutable_copy()'
 
 
-def _decompose_into_cliffords(op: 'cirq.Operation') -> List['cirq.Operation']:
+def _decompose_into_cliffords(op: cirq.Operation) -> List[cirq.Operation]:
     # An operation that can be ignored?
     if isinstance(op.gate, global_phase_op.GlobalPhaseGate):
         return []
@@ -1657,7 +1654,7 @@ _x = cast(pauli_gates.Pauli, pauli_gates.X)  # type: ignore
 _y = cast(pauli_gates.Pauli, pauli_gates.Y)  # type: ignore
 _z = cast(pauli_gates.Pauli, pauli_gates.Z)  # type: ignore
 
-PAULI_GATE_LIKE_TO_INDEX_MAP: Dict['cirq.PAULI_GATE_LIKE', int] = {
+PAULI_GATE_LIKE_TO_INDEX_MAP: Dict[cirq.PAULI_GATE_LIKE, int] = {
     _i: 0,
     _x: 1,
     _y: 2,
@@ -1676,13 +1673,13 @@ PAULI_GATE_LIKE_TO_INDEX_MAP: Dict['cirq.PAULI_GATE_LIKE', int] = {
     3: 3,
 }
 
-_INT_TO_PAULI_OR_IDENTITY: List[Union['cirq.Pauli', 'cirq.IdentityGate']] = [_i, _x, _y, _z]
-_INT_TO_PAULI: List['cirq.Pauli'] = [_x, _y, _z]
+_INT_TO_PAULI_OR_IDENTITY: List[Union[cirq.Pauli, cirq.IdentityGate]] = [_i, _x, _y, _z]
+_INT_TO_PAULI: List[cirq.Pauli] = [_x, _y, _z]
 
 
-PAULI_GATE_LIKE_TO_GATE_MAP: Dict[
-    'cirq.PAULI_GATE_LIKE', Union['cirq.Pauli', 'cirq.IdentityGate']
-] = {k: _INT_TO_PAULI_OR_IDENTITY[v] for k, v in PAULI_GATE_LIKE_TO_INDEX_MAP.items()}
+PAULI_GATE_LIKE_TO_GATE_MAP: Dict[cirq.PAULI_GATE_LIKE, Union[cirq.Pauli, cirq.IdentityGate]] = {
+    k: _INT_TO_PAULI_OR_IDENTITY[v] for k, v in PAULI_GATE_LIKE_TO_INDEX_MAP.items()
+}
 
 
 def _pauli_like_to_pauli_int(key: Any, pauli_gate_like: PAULI_GATE_LIKE):