cirq-core 1.6.0.dev20250501173104__py3-none-any.whl → 1.6.0.dev20250501192724__py3-none-any.whl

cirq/value/classical_data.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 enum
 from typing import Dict, List, Mapping, Optional, Sequence, Tuple, TYPE_CHECKING
@@ -45,21 +47,21 @@ class MeasurementType(enum.IntEnum):
 
 class ClassicalDataStoreReader(abc.ABC):
     @abc.abstractmethod
-    def keys(self) -> Tuple['cirq.MeasurementKey', ...]:
+    def keys(self) -> Tuple[cirq.MeasurementKey, ...]:
         """Gets the measurement keys in the order they were stored."""
 
     @property
     @abc.abstractmethod
-    def records(self) -> Mapping['cirq.MeasurementKey', List[Tuple[int, ...]]]:
+    def records(self) -> Mapping[cirq.MeasurementKey, List[Tuple[int, ...]]]:
         """Gets the a mapping from measurement key to measurement records."""
 
     @property
     @abc.abstractmethod
-    def channel_records(self) -> Mapping['cirq.MeasurementKey', List[int]]:
+    def channel_records(self) -> Mapping[cirq.MeasurementKey, List[int]]:
         """Gets the a mapping from measurement key to channel measurement records."""
 
     @abc.abstractmethod
-    def get_int(self, key: 'cirq.MeasurementKey', index=-1) -> int:
+    def get_int(self, key: cirq.MeasurementKey, index=-1) -> int:
         """Gets the integer corresponding to the measurement.
 
         The integer is determined by summing the qubit-dimensional basis value
@@ -81,7 +83,7 @@ class ClassicalDataStoreReader(abc.ABC):
         """
 
     @abc.abstractmethod
-    def get_digits(self, key: 'cirq.MeasurementKey', index=-1) -> Tuple[int, ...]:
+    def get_digits(self, key: cirq.MeasurementKey, index=-1) -> Tuple[int, ...]:
         """Gets the values of the qubits that were measured into this key.
 
         For example, if the measurement of qubits [q0, q1] produces [0, 1],
@@ -107,7 +109,7 @@ class ClassicalDataStoreReader(abc.ABC):
 class ClassicalDataStore(ClassicalDataStoreReader, abc.ABC):
     @abc.abstractmethod
     def record_measurement(
-        self, key: 'cirq.MeasurementKey', measurement: Sequence[int], qubits: Sequence['cirq.Qid']
+        self, key: cirq.MeasurementKey, measurement: Sequence[int], qubits: Sequence[cirq.Qid]
     ):
         """Records a measurement.
 
@@ -122,7 +124,7 @@ class ClassicalDataStore(ClassicalDataStoreReader, abc.ABC):
         """
 
     @abc.abstractmethod
-    def record_channel_measurement(self, key: 'cirq.MeasurementKey', measurement: int):
+    def record_channel_measurement(self, key: cirq.MeasurementKey, measurement: int):
         """Records a channel measurement.
 
         Args:
@@ -141,12 +143,10 @@ class ClassicalDataDictionaryStore(ClassicalDataStore):
     def __init__(
         self,
         *,
-        _records: Optional[Dict['cirq.MeasurementKey', List[Tuple[int, ...]]]] = None,
-        _measured_qubits: Optional[
-            Dict['cirq.MeasurementKey', List[Tuple['cirq.Qid', ...]]]
-        ] = None,
-        _channel_records: Optional[Dict['cirq.MeasurementKey', List[int]]] = None,
-        _measurement_types: Optional[Dict['cirq.MeasurementKey', 'cirq.MeasurementType']] = None,
+        _records: Optional[Dict[cirq.MeasurementKey, List[Tuple[int, ...]]]] = None,
+        _measured_qubits: Optional[Dict[cirq.MeasurementKey, List[Tuple[cirq.Qid, ...]]]] = None,
+        _channel_records: Optional[Dict[cirq.MeasurementKey, List[int]]] = None,
+        _measurement_types: Optional[Dict[cirq.MeasurementKey, cirq.MeasurementType]] = None,
     ):
         """Initializes a `ClassicalDataDictionaryStore` object."""
         if not _measurement_types:
@@ -165,40 +165,40 @@ class ClassicalDataDictionaryStore(ClassicalDataStore):
             _measured_qubits = {}
         if _channel_records is None:
             _channel_records = {}
-        self._records: Dict['cirq.MeasurementKey', List[Tuple[int, ...]]] = _records
-        self._measured_qubits: Dict['cirq.MeasurementKey', List[Tuple['cirq.Qid', ...]]] = (
+        self._records: Dict[cirq.MeasurementKey, List[Tuple[int, ...]]] = _records
+        self._measured_qubits: Dict[cirq.MeasurementKey, List[Tuple[cirq.Qid, ...]]] = (
             _measured_qubits
         )
-        self._channel_records: Dict['cirq.MeasurementKey', List[int]] = _channel_records
-        self._measurement_types: Dict['cirq.MeasurementKey', 'cirq.MeasurementType'] = (
+        self._channel_records: Dict[cirq.MeasurementKey, List[int]] = _channel_records
+        self._measurement_types: Dict[cirq.MeasurementKey, cirq.MeasurementType] = (
             _measurement_types
         )
 
     @property
-    def records(self) -> Mapping['cirq.MeasurementKey', List[Tuple[int, ...]]]:
+    def records(self) -> Mapping[cirq.MeasurementKey, List[Tuple[int, ...]]]:
         """Gets the a mapping from measurement key to measurement records."""
         return self._records
 
     @property
-    def channel_records(self) -> Mapping['cirq.MeasurementKey', List[int]]:
+    def channel_records(self) -> Mapping[cirq.MeasurementKey, List[int]]:
         """Gets the a mapping from measurement key to channel measurement records."""
         return self._channel_records
 
     @property
-    def measured_qubits(self) -> Mapping['cirq.MeasurementKey', List[Tuple['cirq.Qid', ...]]]:
+    def measured_qubits(self) -> Mapping[cirq.MeasurementKey, List[Tuple[cirq.Qid, ...]]]:
         """Gets the a mapping from measurement key to the qubits measured."""
         return self._measured_qubits
 
     @property
-    def measurement_types(self) -> Mapping['cirq.MeasurementKey', 'cirq.MeasurementType']:
+    def measurement_types(self) -> Mapping[cirq.MeasurementKey, cirq.MeasurementType]:
         """Gets the a mapping from measurement key to the measurement type."""
         return self._measurement_types
 
-    def keys(self) -> Tuple['cirq.MeasurementKey', ...]:
+    def keys(self) -> Tuple[cirq.MeasurementKey, ...]:
         return tuple(self._measurement_types.keys())
 
     def record_measurement(
-        self, key: 'cirq.MeasurementKey', measurement: Sequence[int], qubits: Sequence['cirq.Qid']
+        self, key: cirq.MeasurementKey, measurement: Sequence[int], qubits: Sequence[cirq.Qid]
     ):
         if len(measurement) != len(qubits):
             raise ValueError(f'{len(measurement)} measurements but {len(qubits)} qubits.')
@@ -217,7 +217,7 @@ class ClassicalDataDictionaryStore(ClassicalDataStore):
         measured_qubits.append(tuple(qubits))
         self._records[key].append(tuple(measurement))
 
-    def record_channel_measurement(self, key: 'cirq.MeasurementKey', measurement: int):
+    def record_channel_measurement(self, key: cirq.MeasurementKey, measurement: int):
         if key not in self._measurement_types:
             self._measurement_types[key] = MeasurementType.CHANNEL
             self._channel_records[key] = []
@@ -225,14 +225,14 @@ class ClassicalDataDictionaryStore(ClassicalDataStore):
             raise ValueError(f"Measurement already logged to key {key}")
         self._channel_records[key].append(measurement)
 
-    def get_digits(self, key: 'cirq.MeasurementKey', index=-1) -> Tuple[int, ...]:
+    def get_digits(self, key: cirq.MeasurementKey, index=-1) -> Tuple[int, ...]:
         return (
             self._records[key][index]
             if self._measurement_types[key] == MeasurementType.MEASUREMENT
             else (self._channel_records[key][index],)
         )
 
-    def get_int(self, key: 'cirq.MeasurementKey', index=-1) -> int:
+    def get_int(self, key: cirq.MeasurementKey, index=-1) -> int:
         if key not in self._measurement_types:
             raise KeyError(f'The measurement key {key} is not in {self._measurement_types}')
         measurement_type = self._measurement_types[key]

cirq/value/condition.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 dataclasses
 from typing import Any, Dict, FrozenSet, Mapping, Optional, Tuple, TYPE_CHECKING
@@ -32,15 +34,15 @@ class Condition(abc.ABC):
 
     @property
     @abc.abstractmethod
-    def keys(self) -> Tuple['cirq.MeasurementKey', ...]:
+    def keys(self) -> Tuple[cirq.MeasurementKey, ...]:
         """Gets the control keys."""
 
     @abc.abstractmethod
-    def replace_key(self, current: 'cirq.MeasurementKey', replacement: 'cirq.MeasurementKey'):
+    def replace_key(self, current: cirq.MeasurementKey, replacement: cirq.MeasurementKey):
         """Replaces the control keys."""
 
     @abc.abstractmethod
-    def resolve(self, classical_data: 'cirq.ClassicalDataStoreReader') -> bool:
+    def resolve(self, classical_data: cirq.ClassicalDataStoreReader) -> bool:
         """Resolves the condition based on the measurements."""
 
     @property
@@ -48,24 +50,24 @@ class Condition(abc.ABC):
     def qasm(self):
         """Returns the qasm of this condition."""
 
-    def _qasm_(self, args: 'cirq.QasmArgs', **kwargs) -> Optional[str]:
+    def _qasm_(self, args: cirq.QasmArgs, **kwargs) -> Optional[str]:
         return self.qasm
 
-    def _with_measurement_key_mapping_(self, key_map: Mapping[str, str]) -> 'cirq.Condition':
+    def _with_measurement_key_mapping_(self, key_map: Mapping[str, str]) -> cirq.Condition:
         condition = self
         for k in self.keys:
             condition = condition.replace_key(k, mkp.with_measurement_key_mapping(k, key_map))
         return condition
 
-    def _with_key_path_prefix_(self, path: Tuple[str, ...]) -> 'cirq.Condition':
+    def _with_key_path_prefix_(self, path: Tuple[str, ...]) -> cirq.Condition:
         condition = self
         for k in self.keys:
             condition = condition.replace_key(k, mkp.with_key_path_prefix(k, path))
         return condition
 
     def _with_rescoped_keys_(
-        self, path: Tuple[str, ...], bindable_keys: FrozenSet['cirq.MeasurementKey']
-    ) -> 'cirq.Condition':
+        self, path: Tuple[str, ...], bindable_keys: FrozenSet[cirq.MeasurementKey]
+    ) -> cirq.Condition:
         condition = self
         for key in self.keys:
             for i in range(len(path) + 1):
@@ -85,14 +87,14 @@ class KeyCondition(Condition):
     time of resolution.
     """
 
-    key: 'cirq.MeasurementKey'
+    key: cirq.MeasurementKey
     index: int = -1
 
     @property
     def keys(self):
         return (self.key,)
 
-    def replace_key(self, current: 'cirq.MeasurementKey', replacement: 'cirq.MeasurementKey'):
+    def replace_key(self, current: cirq.MeasurementKey, replacement: cirq.MeasurementKey):
         return KeyCondition(replacement) if self.key == current else self
 
     def __str__(self):
@@ -103,7 +105,7 @@ class KeyCondition(Condition):
             return f'cirq.KeyCondition({self.key!r}, {self.index})'
         return f'cirq.KeyCondition({self.key!r})'
 
-    def resolve(self, classical_data: 'cirq.ClassicalDataStoreReader') -> bool:
+    def resolve(self, classical_data: cirq.ClassicalDataStoreReader) -> bool:
         if self.key not in classical_data.keys():
             raise ValueError(f'Measurement key {self.key} missing when testing classical control')
         return classical_data.get_int(self.key, self.index) != 0
@@ -119,7 +121,7 @@ class KeyCondition(Condition):
     def qasm(self):
         raise ValueError('QASM is defined only for SympyConditions of type key == constant.')
 
-    def _qasm_(self, args: 'cirq.QasmArgs', **kwargs) -> Optional[str]:
+    def _qasm_(self, args: cirq.QasmArgs, **kwargs) -> Optional[str]:
         args.validate_version('2.0', '3.0')
         key_str = str(self.key)
         if key_str not in args.meas_key_id_map:
@@ -162,7 +164,7 @@ class BitMaskKeyCondition(Condition):
         - bitmask: Optional bitmask to apply before doing the comparison.
     """
 
-    key: 'cirq.MeasurementKey' = attrs.field(
+    key: cirq.MeasurementKey = attrs.field(
         converter=lambda x: (
             x
             if isinstance(x, measurement_key.MeasurementKey)
@@ -180,8 +182,8 @@ class BitMaskKeyCondition(Condition):
 
     @staticmethod
     def create_equal_mask(
-        key: 'cirq.MeasurementKey', bitmask: int, *, index: int = -1
-    ) -> 'BitMaskKeyCondition':
+        key: cirq.MeasurementKey, bitmask: int, *, index: int = -1
+    ) -> BitMaskKeyCondition:
         """Creates a condition that evaluates (meas & bitmask) == bitmask."""
         return BitMaskKeyCondition(
             key, index, target_value=bitmask, equal_target=True, bitmask=bitmask
@@ -189,14 +191,14 @@ class BitMaskKeyCondition(Condition):
 
     @staticmethod
     def create_not_equal_mask(
-        key: 'cirq.MeasurementKey', bitmask: int, *, index: int = -1
-    ) -> 'BitMaskKeyCondition':
+        key: cirq.MeasurementKey, bitmask: int, *, index: int = -1
+    ) -> BitMaskKeyCondition:
         """Creates a condition that evaluates (meas & bitmask) != bitmask."""
         return BitMaskKeyCondition(
             key, index, target_value=bitmask, equal_target=False, bitmask=bitmask
         )
 
-    def replace_key(self, current: 'cirq.MeasurementKey', replacement: 'cirq.MeasurementKey'):
+    def replace_key(self, current: cirq.MeasurementKey, replacement: cirq.MeasurementKey):
         return BitMaskKeyCondition(replacement) if self.key == current else self
 
     def __str__(self):
@@ -218,7 +220,7 @@ class BitMaskKeyCondition(Condition):
         parameters = ', '.join(f'{f.name}={repr(values[f.name])}' for f in attrs.fields(type(self)))
         return f'cirq.BitMaskKeyCondition({parameters})'
 
-    def resolve(self, classical_data: 'cirq.ClassicalDataStoreReader') -> bool:
+    def resolve(self, classical_data: cirq.ClassicalDataStoreReader) -> bool:
         if self.key not in classical_data.keys():
             raise ValueError(f'Measurement key {self.key} missing when testing classical control')
         value = classical_data.get_int(self.key, self.index)
@@ -269,7 +271,7 @@ class SympyCondition(Condition):
             # keep the former here.
         )
 
-    def replace_key(self, current: 'cirq.MeasurementKey', replacement: 'cirq.MeasurementKey'):
+    def replace_key(self, current: cirq.MeasurementKey, replacement: cirq.MeasurementKey):
         return SympyCondition(self.expr.subs({str(current): sympy.Symbol(str(replacement))}))
 
     def __str__(self):
@@ -278,7 +280,7 @@ class SympyCondition(Condition):
     def __repr__(self):
         return f'cirq.SympyCondition({proper_repr(self.expr)})'
 
-    def resolve(self, classical_data: 'cirq.ClassicalDataStoreReader') -> bool:
+    def resolve(self, classical_data: cirq.ClassicalDataStoreReader) -> bool:
         missing = [str(k) for k in self.keys if k not in classical_data.keys()]
         if missing:
             raise ValueError(f'Measurement keys {missing} missing when testing classical control')

cirq/value/duration.py

@@ -11,8 +11,11 @@
 # 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.
+
 """A typed time delta that supports picosecond accuracy."""
 
+from __future__ import annotations
+
 import datetime
 from typing import AbstractSet, Any, Dict, List, Optional, Tuple, TYPE_CHECKING, Union
 
@@ -98,7 +101,7 @@ class Duration:
     def _parameter_names_(self) -> AbstractSet[str]:
         return protocols.parameter_names(self._time_vals)
 
-    def _resolve_parameters_(self, resolver: 'cirq.ParamResolver', recursive: bool) -> 'Duration':
+    def _resolve_parameters_(self, resolver: cirq.ParamResolver, recursive: bool) -> Duration:
         return _duration_from_time_vals(
             protocols.resolve_parameters(self._time_vals, resolver, recursive)
         )
@@ -121,16 +124,16 @@ class Duration:
         """Returns the number of milliseconds that the duration spans."""
         return self.total_picos() / 1000_000_000
 
-    def __add__(self, other) -> 'Duration':
+    def __add__(self, other) -> Duration:
         other = _attempt_duration_like_to_duration(other)
         if other is None:
             return NotImplemented
         return _duration_from_time_vals(_add_time_vals(self._time_vals, other._time_vals))
 
-    def __radd__(self, other) -> 'Duration':
+    def __radd__(self, other) -> Duration:
         return self.__add__(other)
 
-    def __sub__(self, other) -> 'Duration':
+    def __sub__(self, other) -> Duration:
         other = _attempt_duration_like_to_duration(other)
         if other is None:
             return NotImplemented
@@ -138,7 +141,7 @@ class Duration:
             _add_time_vals(self._time_vals, [-x for x in other._time_vals])
         )
 
-    def __rsub__(self, other) -> 'Duration':
+    def __rsub__(self, other) -> Duration:
         other = _attempt_duration_like_to_duration(other)
         if other is None:
             return NotImplemented
@@ -146,17 +149,17 @@ class Duration:
             _add_time_vals(other._time_vals, [-x for x in self._time_vals])
         )
 
-    def __mul__(self, other) -> 'Duration':
+    def __mul__(self, other) -> Duration:
         if not isinstance(other, (int, float, sympy.Expr)):
             return NotImplemented
         if other == 0:
             return _duration_from_time_vals([0] * 4)
         return _duration_from_time_vals([x * other for x in self._time_vals])
 
-    def __rmul__(self, other) -> 'Duration':
+    def __rmul__(self, other) -> Duration:
         return self.__mul__(other)
 
-    def __truediv__(self, other) -> Union['Duration', float]:
+    def __truediv__(self, other) -> Union[Duration, float]:
         if isinstance(other, (int, float, sympy.Expr)):
             new_time_vals = [x / other for x in self._time_vals]
             return _duration_from_time_vals(new_time_vals)

cirq/value/linear_dict.py

@@ -14,6 +14,8 @@
 
 """Linear combination represented as mapping of things to coefficients."""
 
+from __future__ import annotations
+
 from typing import (
     AbstractSet,
     Any,
@@ -63,7 +65,7 @@ class _SympyPrinter(sympy.printing.str.StrPrinter):
         return super()._print(expr, **kwargs)
 
 
-def _format_coefficient(format_spec: str, coefficient: 'cirq.TParamValComplex') -> str:
+def _format_coefficient(format_spec: str, coefficient: cirq.TParamValComplex) -> str:
     if isinstance(coefficient, sympy.Basic):
         printer = _SympyPrinter(format_spec)
         return printer.doprint(coefficient)
@@ -83,7 +85,7 @@ def _format_coefficient(format_spec: str, coefficient: 'cirq.TParamValComplex')
     return f'({real_str}+{imag_str}j)'
 
 
-def _format_term(format_spec: str, vector: TVector, coefficient: 'cirq.TParamValComplex') -> str:
+def _format_term(format_spec: str, vector: TVector, coefficient: cirq.TParamValComplex) -> str:
     coefficient_str = _format_coefficient(format_spec, coefficient)
     if not coefficient_str:
         return coefficient_str
@@ -93,7 +95,7 @@ def _format_term(format_spec: str, vector: TVector, coefficient: 'cirq.TParamVal
     return '+' + result
 
 
-def _format_terms(terms: Iterable[Tuple[TVector, 'cirq.TParamValComplex']], format_spec: str):
+def _format_terms(terms: Iterable[Tuple[TVector, cirq.TParamValComplex]], format_spec: str):
     formatted_terms = [_format_term(format_spec, vector, coeff) for vector, coeff in terms]
     s = ''.join(formatted_terms)
     if not s:
@@ -120,7 +122,7 @@ class LinearDict(Generic[TVector], MutableMapping[TVector, 'cirq.TParamValComple
 
     def __init__(
         self,
-        terms: Optional[Mapping[TVector, 'cirq.TParamValComplex']] = None,
+        terms: Optional[Mapping[TVector, cirq.TParamValComplex]] = None,
         validator: Optional[Callable[[TVector], bool]] = None,
     ) -> None:
         """Initializes linear combination from a collection of terms.
@@ -136,7 +138,7 @@ class LinearDict(Generic[TVector], MutableMapping[TVector, 'cirq.TParamValComple
         """
         self._has_validator = validator is not None
         self._is_valid = validator or (lambda x: True)
-        self._terms: Dict[TVector, 'cirq.TParamValComplex'] = {}
+        self._terms: Dict[TVector, cirq.TParamValComplex] = {}
         if terms is not None:
             self.update(terms)
 
@@ -172,31 +174,31 @@ class LinearDict(Generic[TVector], MutableMapping[TVector, 'cirq.TParamValComple
         snapshot = self.copy().clean(atol=0)
         return snapshot._terms.keys()
 
-    def values(self) -> ValuesView['cirq.TParamValComplex']:
+    def values(self) -> ValuesView[cirq.TParamValComplex]:
         snapshot = self.copy().clean(atol=0)
         return snapshot._terms.values()
 
-    def items(self) -> ItemsView[TVector, 'cirq.TParamValComplex']:
+    def items(self) -> ItemsView[TVector, cirq.TParamValComplex]:
         snapshot = self.copy().clean(atol=0)
         return snapshot._terms.items()
 
     # pylint: disable=function-redefined
     @overload
     def update(
-        self, other: Mapping[TVector, 'cirq.TParamValComplex'], **kwargs: 'cirq.TParamValComplex'
+        self, other: Mapping[TVector, cirq.TParamValComplex], **kwargs: cirq.TParamValComplex
     ) -> None:
         pass
 
     @overload
     def update(
         self,
-        other: Iterable[Tuple[TVector, 'cirq.TParamValComplex']],
-        **kwargs: 'cirq.TParamValComplex',
+        other: Iterable[Tuple[TVector, cirq.TParamValComplex]],
+        **kwargs: cirq.TParamValComplex,
     ) -> None:
         pass
 
     @overload
-    def update(self, *args: Any, **kwargs: 'cirq.TParamValComplex') -> None:
+    def update(self, *args: Any, **kwargs: cirq.TParamValComplex) -> None:
         pass
 
     def update(self, *args, **kwargs):
@@ -211,11 +213,11 @@ class LinearDict(Generic[TVector], MutableMapping[TVector, 'cirq.TParamValComple
         self.clean(atol=0)
 
     @overload
-    def get(self, vector: TVector) -> 'cirq.TParamValComplex':
+    def get(self, vector: TVector) -> cirq.TParamValComplex:
         pass
 
     @overload
-    def get(self, vector: TVector, default: TDefault) -> Union['cirq.TParamValComplex', TDefault]:
+    def get(self, vector: TVector, default: TDefault) -> Union[cirq.TParamValComplex, TDefault]:
         pass
 
     def get(self, vector, default=0):
@@ -228,10 +230,10 @@ class LinearDict(Generic[TVector], MutableMapping[TVector, 'cirq.TParamValComple
     def __contains__(self, vector: Any) -> bool:
         return vector in self._terms and self._terms[vector] != 0
 
-    def __getitem__(self, vector: TVector) -> 'cirq.TParamValComplex':
+    def __getitem__(self, vector: TVector) -> cirq.TParamValComplex:
         return self._terms.get(vector, 0)
 
-    def __setitem__(self, vector: TVector, coefficient: 'cirq.TParamValComplex') -> None:
+    def __setitem__(self, vector: TVector, coefficient: cirq.TParamValComplex) -> None:
         self._check_vector_valid(vector)
         if coefficient != 0:
             self._terms[vector] = coefficient
@@ -279,21 +281,21 @@ class LinearDict(Generic[TVector], MutableMapping[TVector, 'cirq.TParamValComple
         factory = type(self)
         return factory({v: -c for v, c in self.items()})
 
-    def __imul__(self, a: 'cirq.TParamValComplex') -> Self:
+    def __imul__(self, a: cirq.TParamValComplex) -> Self:
         for vector in self:
             self._terms[vector] *= a
         self.clean(atol=0)
         return self
 
-    def __mul__(self, a: 'cirq.TParamValComplex') -> Self:
+    def __mul__(self, a: cirq.TParamValComplex) -> Self:
         result = self.copy()
         result *= a
         return result.copy()
 
-    def __rmul__(self, a: 'cirq.TParamValComplex') -> Self:
+    def __rmul__(self, a: cirq.TParamValComplex) -> Self:
         return self.__mul__(a)
 
-    def __truediv__(self, a: 'cirq.TParamValComplex') -> Self:
+    def __truediv__(self, a: cirq.TParamValComplex) -> Self:
         return self.__mul__(1 / a)
 
     def __bool__(self) -> bool:
@@ -370,7 +372,7 @@ class LinearDict(Generic[TVector], MutableMapping[TVector, 'cirq.TParamValComple
     def _parameter_names_(self) -> AbstractSet[str]:
         return set(name for v in self._terms.values() for name in protocols.parameter_names(v))
 
-    def _resolve_parameters_(self, resolver: 'cirq.ParamResolver', recursive: bool) -> 'LinearDict':
+    def _resolve_parameters_(self, resolver: cirq.ParamResolver, recursive: bool) -> LinearDict:
         result = self.copy()
         result.update(
             {

cirq/value/periodic_value.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, TYPE_CHECKING
 
 import sympy
@@ -35,7 +37,7 @@ class PeriodicValue:
     interval.
     """
 
-    def __init__(self, value: 'cirq.TParamVal', period: 'cirq.TParamVal'):
+    def __init__(self, value: cirq.TParamVal, period: cirq.TParamVal):
         """Initializes the equivalence class.
 
         Args:
@@ -99,9 +101,7 @@ class PeriodicValue:
 
         return parameter_names(self.value) | parameter_names(self.period)
 
-    def _resolve_parameters_(
-        self, resolver: 'cirq.ParamResolver', recursive: bool
-    ) -> 'PeriodicValue':
+    def _resolve_parameters_(self, resolver: cirq.ParamResolver, recursive: bool) -> PeriodicValue:
         # HACK: Avoids circular dependencies.
         from cirq.protocols import resolve_parameters
 

cirq/value/probability.py

@@ -14,6 +14,8 @@
 
 """Utilities for handling probabilities."""
 
+from __future__ import annotations
+
 from typing import TYPE_CHECKING
 
 import numpy as np
@@ -44,7 +46,7 @@ def validate_probability(p: float, p_str: str) -> float:
     return p
 
 
-def state_vector_to_probabilities(state_vector: 'cirq.STATE_VECTOR_LIKE') -> np.ndarray:
+def state_vector_to_probabilities(state_vector: cirq.STATE_VECTOR_LIKE) -> np.ndarray:
     """Function to transform a state vector like object into a numpy array of probabilities."""
     valid_state_vector = to_valid_state_vector(state_vector)
     return np.abs(valid_state_vector) ** 2