cirq-core 1.6.0.dev20250428201230__py3-none-any.whl → 1.6.0.dev20250429004516__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.dev20250428201230"
+__version__ = "1.6.0.dev20250429004516"

cirq/_version_test.py

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

cirq/protocols/measurement_key_protocol.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.
+
 """Protocol for object that have measurement keys."""
 
+from __future__ import annotations
+
 from types import NotImplementedType
 from typing import Any, FrozenSet, Mapping, Optional, Tuple, TYPE_CHECKING, Union
 
@@ -60,7 +63,7 @@ class SupportsMeasurementKey(Protocol):
         """Return if this object is (or contains) a measurement."""
 
     @doc_private
-    def _measurement_key_obj_(self) -> 'cirq.MeasurementKey':
+    def _measurement_key_obj_(self) -> cirq.MeasurementKey:
         """Return the key object that will be used to identify this measurement.
 
         When a measurement occurs, either on hardware, or in a simulation,
@@ -71,7 +74,7 @@ class SupportsMeasurementKey(Protocol):
     @doc_private
     def _measurement_key_objs_(
         self,
-    ) -> Union[FrozenSet['cirq.MeasurementKey'], NotImplementedType, None]:
+    ) -> Union[FrozenSet[cirq.MeasurementKey], NotImplementedType, None]:
         """Return the key objects for measurements performed by the receiving object.
 
         When a measurement occurs, either on hardware, or in a simulation,
@@ -175,7 +178,7 @@ def measurement_key_name(val: Any, default: Any = RaiseTypeErrorIfNotProvided):
 
 def _measurement_key_objs_from_magic_methods(
     val: Any,
-) -> Union[FrozenSet['cirq.MeasurementKey'], NotImplementedType, None]:
+) -> Union[FrozenSet[cirq.MeasurementKey], NotImplementedType, None]:
     """Uses the measurement key related magic methods to get the `MeasurementKey`s for this
     object."""
 
@@ -209,7 +212,7 @@ def _measurement_key_names_from_magic_methods(
     return result
 
 
-def measurement_key_objs(val: Any) -> FrozenSet['cirq.MeasurementKey']:
+def measurement_key_objs(val: Any) -> FrozenSet[cirq.MeasurementKey]:
     """Gets the measurement key objects of measurements within the given value.
 
     Args:
@@ -316,9 +319,7 @@ def with_key_path_prefix(val: Any, prefix: Tuple[str, ...]):
 
 
 def with_rescoped_keys(
-    val: Any,
-    path: Tuple[str, ...],
-    bindable_keys: Optional[FrozenSet['cirq.MeasurementKey']] = None,
+    val: Any, path: Tuple[str, ...], bindable_keys: Optional[FrozenSet[cirq.MeasurementKey]] = None
 ):
     """Rescopes any measurement and control keys to the provided path, given the existing keys.
 

cirq/protocols/pow_protocol.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 Any, Callable, Optional, overload, TYPE_CHECKING, TypeVar, Union
 
 if TYPE_CHECKING:
@@ -26,29 +28,27 @@ TDefault = TypeVar('TDefault')
 
 # pylint: disable=function-redefined, redefined-builtin
 @overload
-def pow(val: 'cirq.Gate', exponent: Any) -> 'cirq.Gate':
+def pow(val: cirq.Gate, exponent: Any) -> cirq.Gate:
     pass
 
 
 @overload
-def pow(val: 'cirq.Operation', exponent: Any) -> 'cirq.Operation':
+def pow(val: cirq.Operation, exponent: Any) -> cirq.Operation:
     pass
 
 
 @overload
-def pow(val: 'cirq.Gate', exponent: Any, default: TDefault) -> Union[TDefault, 'cirq.Gate']:
+def pow(val: cirq.Gate, exponent: Any, default: TDefault) -> Union[TDefault, cirq.Gate]:
     pass
 
 
 @overload
-def pow(
-    val: 'cirq.Operation', exponent: Any, default: TDefault
-) -> Union[TDefault, 'cirq.Operation']:
+def pow(val: cirq.Operation, exponent: Any, default: TDefault) -> Union[TDefault, cirq.Operation]:
     pass
 
 
 @overload
-def pow(val: 'cirq.Circuit', exponent: int, default: TDefault) -> Union[TDefault, 'cirq.Circuit']:
+def pow(val: cirq.Circuit, exponent: int, default: TDefault) -> Union[TDefault, cirq.Circuit]:
     pass
 
 

cirq/protocols/qasm.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import string
 from types import NotImplementedType
 from typing import Any, Dict, Iterable, Optional, Tuple, TYPE_CHECKING, TypeVar, Union
@@ -36,7 +38,7 @@ class QasmArgs(string.Formatter):
         self,
         precision: int = 10,
         version: str = '2.0',
-        qubit_id_map: Optional[Dict['cirq.Qid', str]] = None,
+        qubit_id_map: Optional[Dict[cirq.Qid, str]] = None,
         meas_key_id_map: Optional[Dict[str, str]] = None,
         meas_key_bitcount: Optional[Dict[str, int]] = None,
     ) -> None:
@@ -124,7 +126,7 @@ class SupportsQasmWithArgsAndQubits(Protocol):
 
     @doc_private
     def _qasm_(
-        self, qubits: Tuple['cirq.Qid'], args: QasmArgs
+        self, qubits: Tuple[cirq.Qid], args: QasmArgs
     ) -> Union[None, NotImplementedType, str]:
         pass
 
@@ -134,7 +136,7 @@ def qasm(
     val: Any,
     *,
     args: Optional[QasmArgs] = None,
-    qubits: Optional[Iterable['cirq.Qid']] = None,
+    qubits: Optional[Iterable[cirq.Qid]] = None,
     default: TDefault = RaiseTypeErrorIfNotProvided,
 ) -> Union[str, TDefault]:
     """Returns QASM code for the given value, if possible.

cirq/protocols/resolve_parameters.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import numbers
 from typing import AbstractSet, Any, cast, TYPE_CHECKING, TypeVar
 
@@ -48,7 +50,7 @@ class SupportsParameterization(Protocol):
         """
 
     @doc_private
-    def _resolve_parameters_(self, resolver: 'cirq.ParamResolver', recursive: bool) -> Self:
+    def _resolve_parameters_(self, resolver: cirq.ParamResolver, recursive: bool) -> Self:
         """Resolve the parameters in the effect."""
 
 
@@ -133,7 +135,7 @@ def parameter_symbols(val: Any) -> AbstractSet[sympy.Symbol]:
 
 
 def resolve_parameters(
-    val: T, param_resolver: 'cirq.ParamResolverOrSimilarType', recursive: bool = True
+    val: T, param_resolver: cirq.ParamResolverOrSimilarType, recursive: bool = True
 ) -> T:
     """Resolves symbol parameters in the effect using the param resolver.
 
@@ -195,6 +197,6 @@ def resolve_parameters(
         return val
 
 
-def resolve_parameters_once(val: Any, param_resolver: 'cirq.ParamResolverOrSimilarType'):
+def resolve_parameters_once(val: Any, param_resolver: cirq.ParamResolverOrSimilarType):
     """Performs a single parameter resolution step using the param resolver."""
     return resolve_parameters(val, param_resolver, False)

cirq/qis/clifford_tableau.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
 from typing import Any, Dict, List, Optional, Sequence, TYPE_CHECKING
 
@@ -286,10 +288,10 @@ class CliffordTableau(StabilizerState):
             and np.array_equal(self.zs, other.zs)
         )
 
-    def __copy__(self) -> 'CliffordTableau':
+    def __copy__(self) -> CliffordTableau:
         return self.copy()
 
-    def copy(self, deep_copy_buffers: bool = True) -> 'CliffordTableau':
+    def copy(self, deep_copy_buffers: bool = True) -> CliffordTableau:
         state = CliffordTableau(self.n)
         state.rs = self.rs.copy()
         state.xs = self.xs.copy()
@@ -364,7 +366,7 @@ class CliffordTableau(StabilizerState):
 
         return '\n'.join([title_row, divider, *contents]) + '\n'
 
-    def then(self, second: 'CliffordTableau') -> 'CliffordTableau':
+    def then(self, second: CliffordTableau) -> CliffordTableau:
         """Returns a composed CliffordTableau of this tableau and the second tableau.
 
         Then composed tableau is equal to (up to global phase) the composed
@@ -431,7 +433,7 @@ class CliffordTableau(StabilizerState):
 
         return merged_tableau
 
-    def inverse(self) -> 'CliffordTableau':
+    def inverse(self) -> CliffordTableau:
         """Returns the inverse Clifford tableau of this tableau."""
         ret_table = CliffordTableau(num_qubits=self.n)
         # It relies on the symplectic property of Clifford tableau.
@@ -450,7 +452,7 @@ class CliffordTableau(StabilizerState):
         ret_table.rs = ret_table.then(self).rs
         return ret_table
 
-    def __matmul__(self, second: 'CliffordTableau'):
+    def __matmul__(self, second: CliffordTableau):
         if not isinstance(second, CliffordTableau):
             return NotImplemented
         return second.then(self)
@@ -481,7 +483,7 @@ class CliffordTableau(StabilizerState):
         self._xs[q1, :] ^= self._xs[q2, :]
         self._zs[q1, :] ^= self._zs[q2, :]
 
-    def _row_to_dense_pauli(self, i: int) -> 'cirq.DensePauliString':
+    def _row_to_dense_pauli(self, i: int) -> cirq.DensePauliString:
         """Return a dense Pauli string for the given row in the tableau.
 
         Args:
@@ -509,12 +511,12 @@ class CliffordTableau(StabilizerState):
                 pauli_mask += "I"
         return DensePauliString(pauli_mask, coefficient=coefficient)
 
-    def stabilizers(self) -> List['cirq.DensePauliString']:
+    def stabilizers(self) -> List[cirq.DensePauliString]:
         """Returns the stabilizer generators of the state. These
         are n operators {S_1,S_2,...,S_n} such that S_i |psi> = |psi>"""
         return [self._row_to_dense_pauli(i) for i in range(self.n, 2 * self.n)]
 
-    def destabilizers(self) -> List['cirq.DensePauliString']:
+    def destabilizers(self) -> List[cirq.DensePauliString]:
         """Returns the destabilizer generators of the state. These
         are n operators {S_1,S_2,...,S_n} such that along with the stabilizer
         generators above generate the full Pauli group on n qubits."""
@@ -662,7 +664,7 @@ class CliffordTableau(StabilizerState):
         pass
 
     def measure(
-        self, axes: Sequence[int], seed: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None
+        self, axes: Sequence[int], seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None
     ) -> List[int]:
         return [self._measure(axis, random_state.parse_random_state(seed)) for axis in axes]
 

cirq/qis/measures.py

@@ -11,8 +11,10 @@
 # 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.
+
 """Measures on and between quantum states and operations."""
 
+from __future__ import annotations
 
 from typing import Optional, Tuple, TYPE_CHECKING
 
@@ -58,9 +60,7 @@ def _validate_int_state(state: int, qid_shape: Optional[Tuple[int, ...]]) -> Non
             )
 
 
-def _validate_product_state(
-    state: 'cirq.ProductState', qid_shape: Optional[Tuple[int, ...]]
-) -> None:
+def _validate_product_state(state: cirq.ProductState, qid_shape: Optional[Tuple[int, ...]]) -> None:
     if qid_shape is not None and qid_shape != (2,) * len(state):
         raise ValueError(
             'Invalid state for given qid shape: '
@@ -70,8 +70,8 @@ def _validate_product_state(
 
 
 def fidelity(
-    state1: 'cirq.QUANTUM_STATE_LIKE',
-    state2: 'cirq.QUANTUM_STATE_LIKE',
+    state1: cirq.QUANTUM_STATE_LIKE,
+    state2: cirq.QUANTUM_STATE_LIKE,
     qid_shape: Optional[Tuple[int, ...]] = None,
     validate: bool = True,
     atol: float = 1e-7,
@@ -255,7 +255,7 @@ def _fidelity_state_vectors_or_density_matrices(state1: np.ndarray, state2: np.n
 
 
 def von_neumann_entropy(
-    state: 'cirq.QUANTUM_STATE_LIKE',
+    state: cirq.QUANTUM_STATE_LIKE,
     qid_shape: Optional[Tuple[int, ...]] = None,
     validate: bool = True,
     atol: float = 1e-7,
@@ -298,7 +298,7 @@ def von_neumann_entropy(
     return 0.0
 
 
-def entanglement_fidelity(operation: 'cirq.SupportsKraus') -> float:
+def entanglement_fidelity(operation: cirq.SupportsKraus) -> float:
     r"""Returns entanglement fidelity of a given quantum channel.
 
     Entanglement fidelity $F_e$ of a quantum channel $E: L(H) \to L(H)$ is the overlap between

cirq/qis/quantum_state_representation.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
 from typing import List, Sequence, Tuple, TYPE_CHECKING
 
@@ -38,7 +40,7 @@ class QuantumStateRepresentation(metaclass=abc.ABCMeta):
 
     @abc.abstractmethod
     def measure(
-        self, axes: Sequence[int], seed: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None
+        self, axes: Sequence[int], seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None
     ) -> List[int]:
         """Measures the state.
 
@@ -50,10 +52,7 @@ class QuantumStateRepresentation(metaclass=abc.ABCMeta):
         """
 
     def sample(
-        self,
-        axes: Sequence[int],
-        repetitions: int = 1,
-        seed: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None,
+        self, axes: Sequence[int], repetitions: int = 1, seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None
     ) -> np.ndarray:
         """Samples the state. Subclasses can override with more performant method.
 

cirq/qis/states.py

@@ -14,6 +14,8 @@
 
 """Classes and methods for quantum states."""
 
+from __future__ import annotations
+
 import itertools
 from typing import Any, cast, Iterable, List, Optional, Sequence, Set, Tuple, TYPE_CHECKING, Union
 
@@ -64,7 +66,7 @@ class QuantumState:
         data: np.ndarray,
         qid_shape: Optional[Tuple[int, ...]] = None,
         *,  # Force keyword arguments
-        dtype: Optional['DTypeLike'] = None,
+        dtype: Optional[DTypeLike] = None,
         validate: bool = True,
         atol: float = 1e-7,
     ) -> None:
@@ -156,7 +158,7 @@ class QuantumState:
         return self.data.shape == (self._dim, self._dim)
 
     def validate(
-        self, *, dtype: Optional['DTypeLike'] = None, atol=1e-7  # Force keyword arguments
+        self, *, dtype: Optional[DTypeLike] = None, atol=1e-7  # Force keyword arguments
     ) -> None:
         """Check if this quantum state is valid.
 
@@ -188,12 +190,12 @@ class QuantumState:
 
 
 def quantum_state(
-    state: 'cirq.QUANTUM_STATE_LIKE',
+    state: cirq.QUANTUM_STATE_LIKE,
     qid_shape: Optional[Tuple[int, ...]] = None,
     *,  # Force keyword arguments
     copy: bool = False,
     validate: bool = True,
-    dtype: Optional['DTypeLike'] = None,
+    dtype: Optional[DTypeLike] = None,
     atol: float = 1e-7,
 ) -> QuantumState:
     """Create a QuantumState object from a state-like object.
@@ -297,7 +299,7 @@ def density_matrix(
     *,  # Force keyword arguments
     copy: bool = False,
     validate: bool = True,
-    dtype: Optional['DTypeLike'] = None,
+    dtype: Optional[DTypeLike] = None,
     atol: float = 1e-7,
 ) -> QuantumState:
     """Create a QuantumState object from a density matrix.
@@ -350,7 +352,7 @@ _NON_INT_STATE_LIKE = Union[
 ]
 
 
-def infer_qid_shape(*states: 'cirq.QUANTUM_STATE_LIKE') -> Tuple[int, ...]:
+def infer_qid_shape(*states: cirq.QUANTUM_STATE_LIKE) -> Tuple[int, ...]:
     """Infer the qid shape of a set of states.
 
     This is a heuristic to determine a qid shape compatible with all of the
@@ -410,7 +412,7 @@ def infer_qid_shape(*states: 'cirq.QUANTUM_STATE_LIKE') -> Tuple[int, ...]:
     return qid_shape
 
 
-def _potential_qid_shapes(state: _NON_INT_STATE_LIKE) -> '_QidShapeSet':
+def _potential_qid_shapes(state: _NON_INT_STATE_LIKE) -> _QidShapeSet:
     """Return a set of qid shapes compatible with a given state."""
     if isinstance(state, QuantumState):
         return _QidShapeSet(explicit_qid_shapes={state.qid_shape})
@@ -472,7 +474,7 @@ class _QidShapeSet:
         self.unfactorized_total_dimension = unfactorized_total_dimension
         self.min_qudit_dimensions = min_qudit_dimensions
 
-    def intersection_subset(self, other: '_QidShapeSet'):
+    def intersection_subset(self, other: _QidShapeSet):
         """Return a subset of the intersection with other qid shape set."""
         explicit_qid_shapes = self.explicit_qid_shapes & other.explicit_qid_shapes
         unfactorized_total_dimension = None
@@ -761,11 +763,11 @@ def dirac_notation(
 
 
 def to_valid_state_vector(
-    state_rep: 'cirq.STATE_VECTOR_LIKE',
+    state_rep: cirq.STATE_VECTOR_LIKE,
     num_qubits: Optional[int] = None,
     *,  # Force keyword arguments
     qid_shape: Optional[Sequence[int]] = None,
-    dtype: Optional['DTypeLike'] = None,
+    dtype: Optional[DTypeLike] = None,
     atol: float = 1e-7,
 ) -> np.ndarray:
     """Verifies the state_rep is valid and converts it to ndarray form.
@@ -830,7 +832,7 @@ def to_valid_state_vector(
 
 
 def _qudit_values_to_state_tensor(
-    *, state_vector: np.ndarray, qid_shape: Tuple[int, ...], dtype: Optional['DTypeLike']
+    *, state_vector: np.ndarray, qid_shape: Tuple[int, ...], dtype: Optional[DTypeLike]
 ) -> np.ndarray:
     for i in range(len(qid_shape)):
         s = state_vector[i]
@@ -863,7 +865,7 @@ def validate_normalized_state_vector(
     state_vector: np.ndarray,
     *,  # Force keyword arguments
     qid_shape: Tuple[int, ...],
-    dtype: Optional['DTypeLike'] = None,
+    dtype: Optional[DTypeLike] = None,
     atol: float = 1e-7,
 ) -> None:
     """Checks that the given state vector is valid.
@@ -928,11 +930,11 @@ def validate_indices(num_qubits: int, indices: Sequence[int]) -> None:
 
 
 def to_valid_density_matrix(
-    density_matrix_rep: Union[np.ndarray, 'cirq.STATE_VECTOR_LIKE'],
+    density_matrix_rep: Union[np.ndarray, cirq.STATE_VECTOR_LIKE],
     num_qubits: Optional[int] = None,
     *,  # Force keyword arguments
     qid_shape: Optional[Tuple[int, ...]] = None,
-    dtype: Optional['DTypeLike'] = None,
+    dtype: Optional[DTypeLike] = None,
     atol: float = 1e-7,
 ) -> np.ndarray:
     """Verifies the density_matrix_rep is valid and converts it to ndarray form.
@@ -981,7 +983,7 @@ def validate_density_matrix(
     density_matrix: np.ndarray,
     *,  # Force keyword arguments
     qid_shape: Tuple[int, ...],
-    dtype: Optional['DTypeLike'] = None,
+    dtype: Optional[DTypeLike] = None,
     atol: float = 1e-7,
 ) -> None:
     """Checks that the given density matrix is valid.
@@ -1049,7 +1051,7 @@ def one_hot(
     index: Union[None, int, Sequence[int]] = None,
     shape: Union[int, Sequence[int]],
     value: Any = 1,
-    dtype: 'DTypeLike',
+    dtype: DTypeLike,
 ) -> np.ndarray:
     """Returns a numpy array with all 0s and a single non-zero entry(default 1).
 
@@ -1070,7 +1072,7 @@ def one_hot(
     return result
 
 
-def eye_tensor(half_shape: Tuple[int, ...], *, dtype: 'DTypeLike') -> np.ndarray:
+def eye_tensor(half_shape: Tuple[int, ...], *, dtype: DTypeLike) -> np.ndarray:
     """Returns an identity matrix reshaped into a tensor.
 
     Args:

cirq/sim/classical_simulator.py

@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
 
 from copy import copy, deepcopy
 from typing import Any, Dict, Generic, List, Optional, Sequence, TYPE_CHECKING, Union
@@ -45,7 +46,7 @@ class ClassicalBasisState(qis.QuantumStateRepresentation):
         """
         self.basis = initial_state
 
-    def copy(self, deep_copy_buffers: bool = True) -> 'ClassicalBasisState':
+    def copy(self, deep_copy_buffers: bool = True) -> ClassicalBasisState:
         """Creates a copy of the ClassicalBasisState object.
 
         Args:
@@ -58,7 +59,7 @@ class ClassicalBasisState(qis.QuantumStateRepresentation):
         )
 
     def measure(
-        self, axes: Sequence[int], seed: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None
+        self, axes: Sequence[int], seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None
     ) -> List[int]:
         """Measures the density matrix.
 
@@ -77,8 +78,8 @@ class ClassicalBasisSimState(SimulationState[ClassicalBasisState]):
     def __init__(
         self,
         initial_state: Union[int, List[int]] = 0,
-        qubits: Optional[Sequence['cirq.Qid']] = None,
-        classical_data: Optional['cirq.ClassicalDataStore'] = None,
+        qubits: Optional[Sequence[cirq.Qid]] = None,
+        classical_data: Optional[cirq.ClassicalDataStore] = None,
     ):
         """Initializes the ClassicalBasisSimState object.
 
@@ -105,7 +106,7 @@ class ClassicalBasisSimState(SimulationState[ClassicalBasisState]):
             raise ValueError('initial_state must be an int or List[int] or np.ndarray')
         super().__init__(state=state, qubits=qubits, classical_data=classical_data)
 
-    def _act_on_fallback_(self, action, qubits: Sequence['cirq.Qid'], allow_decompose: bool = True):
+    def _act_on_fallback_(self, action, qubits: Sequence[cirq.Qid], allow_decompose: bool = True):
         """Acts on the state with a given operation.
 
         Args:
@@ -182,7 +183,7 @@ class ClassicalStateSimulator(
     """A simulator that accepts only gates with classical counterparts."""
 
     def __init__(
-        self, *, noise: 'cirq.NOISE_MODEL_LIKE' = None, split_untangled_states: bool = False
+        self, *, noise: cirq.NOISE_MODEL_LIKE = None, split_untangled_states: bool = False
     ):
         """Initializes a ClassicalStateSimulator.
 
@@ -199,10 +200,10 @@ class ClassicalStateSimulator(
 
     def _create_simulator_trial_result(
         self,
-        params: 'cirq.ParamResolver',
+        params: cirq.ParamResolver,
         measurements: Dict[str, np.ndarray],
-        final_simulator_state: 'cirq.SimulationStateBase[ClassicalBasisSimState]',
-    ) -> 'ClassicalStateTrialResult[ClassicalBasisSimState]':
+        final_simulator_state: cirq.SimulationStateBase[ClassicalBasisSimState],
+    ) -> ClassicalStateTrialResult[ClassicalBasisSimState]:
         """Creates a trial result for the simulator.
 
         Args:
@@ -217,8 +218,8 @@ class ClassicalStateSimulator(
         )
 
     def _create_step_result(
-        self, sim_state: 'cirq.SimulationStateBase[ClassicalBasisSimState]'
-    ) -> 'ClassicalStateStepResult[ClassicalBasisSimState]':
+        self, sim_state: cirq.SimulationStateBase[ClassicalBasisSimState]
+    ) -> ClassicalStateStepResult[ClassicalBasisSimState]:
         """Creates a step result for the simulator.
 
         Args:
@@ -231,9 +232,9 @@ class ClassicalStateSimulator(
     def _create_partial_simulation_state(
         self,
         initial_state: Any,
-        qubits: Sequence['cirq.Qid'],
-        classical_data: 'cirq.ClassicalDataStore',
-    ) -> 'ClassicalBasisSimState':
+        qubits: Sequence[cirq.Qid],
+        classical_data: cirq.ClassicalDataStore,
+    ) -> ClassicalBasisSimState:
         """Creates a partial simulation state for the simulator.
 
         Args: