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

cirq/sim/clifford/clifford_simulator.py

@@ -30,6 +30,8 @@ The quantum state is specified in two forms:
     to state vector amplitudes.
 """
 
+from __future__ import annotations
+
 from typing import Any, Dict, List, Sequence, Union
 
 import numpy as np
@@ -50,7 +52,7 @@ class CliffordSimulator(
     """An efficient simulator for Clifford circuits."""
 
     def __init__(
-        self, seed: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None, split_untangled_states: bool = False
+        self, seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None, split_untangled_states: bool = False
     ):
         """Creates instance of `CliffordSimulator`.
 
@@ -63,17 +65,17 @@ class CliffordSimulator(
         super().__init__(seed=seed, split_untangled_states=split_untangled_states)
 
     @staticmethod
-    def is_supported_operation(op: 'cirq.Operation') -> bool:
+    def is_supported_operation(op: cirq.Operation) -> bool:
         """Checks whether given operation can be simulated by this simulator."""
         # TODO: support more general Pauli measurements
         return protocols.has_stabilizer_effect(op)
 
     def _create_partial_simulation_state(
         self,
-        initial_state: Union[int, 'cirq.StabilizerChFormSimulationState'],
-        qubits: Sequence['cirq.Qid'],
-        classical_data: 'cirq.ClassicalDataStore',
-    ) -> 'cirq.StabilizerChFormSimulationState':
+        initial_state: Union[int, cirq.StabilizerChFormSimulationState],
+        qubits: Sequence[cirq.Qid],
+        classical_data: cirq.ClassicalDataStore,
+    ) -> cirq.StabilizerChFormSimulationState:
         """Creates the StabilizerChFormSimulationState for a circuit.
 
         Args:
@@ -101,15 +103,15 @@ class CliffordSimulator(
         )
 
     def _create_step_result(
-        self, sim_state: 'cirq.SimulationStateBase[clifford.StabilizerChFormSimulationState]'
+        self, sim_state: cirq.SimulationStateBase[clifford.StabilizerChFormSimulationState]
     ):
         return CliffordSimulatorStepResult(sim_state=sim_state)
 
     def _create_simulator_trial_result(
         self,
-        params: 'cirq.ParamResolver',
+        params: cirq.ParamResolver,
         measurements: Dict[str, np.ndarray],
-        final_simulator_state: 'cirq.SimulationStateBase[cirq.StabilizerChFormSimulationState]',
+        final_simulator_state: cirq.SimulationStateBase[cirq.StabilizerChFormSimulationState],
     ):
         return CliffordTrialResult(
             params=params, measurements=measurements, final_simulator_state=final_simulator_state
@@ -121,16 +123,16 @@ class CliffordTrialResult(
 ):
     def __init__(
         self,
-        params: 'cirq.ParamResolver',
+        params: cirq.ParamResolver,
         measurements: Dict[str, np.ndarray],
-        final_simulator_state: 'cirq.SimulationStateBase[cirq.StabilizerChFormSimulationState]',
+        final_simulator_state: cirq.SimulationStateBase[cirq.StabilizerChFormSimulationState],
     ) -> None:
         super().__init__(
             params=params, measurements=measurements, final_simulator_state=final_simulator_state
         )
 
     @property
-    def final_state(self) -> 'cirq.CliffordState':
+    def final_state(self) -> cirq.CliffordState:
         state = self._get_merged_sim_state()
         clifford_state = CliffordState(state.qubit_map)
         clifford_state.ch_form = state.state.copy()
@@ -152,7 +154,7 @@ class CliffordSimulatorStepResult(
     """A `StepResult` that includes `StateVectorMixin` methods."""
 
     def __init__(
-        self, sim_state: 'cirq.SimulationStateBase[clifford.StabilizerChFormSimulationState]'
+        self, sim_state: cirq.SimulationStateBase[clifford.StabilizerChFormSimulationState]
     ):
         """Results of a step of the simulator.
         Attributes:
@@ -199,7 +201,7 @@ class CliffordState:
     Gates and measurements are applied to each representation in O(n^2) time.
     """
 
-    def __init__(self, qubit_map, initial_state: Union[int, 'cirq.StabilizerStateChForm'] = 0):
+    def __init__(self, qubit_map, initial_state: Union[int, cirq.StabilizerStateChForm] = 0):
         self.qubit_map = qubit_map
         self.n = len(qubit_map)
 
@@ -222,7 +224,7 @@ class CliffordState:
     def _value_equality_values_(self) -> Any:
         return self.qubit_map, self.ch_form
 
-    def copy(self) -> 'cirq.CliffordState':
+    def copy(self) -> cirq.CliffordState:
         state = CliffordState(self.qubit_map)
         state.ch_form = self.ch_form.copy()
 
@@ -241,7 +243,7 @@ class CliffordState:
     def state_vector(self):
         return self.ch_form.state_vector()
 
-    def apply_unitary(self, op: 'cirq.Operation'):
+    def apply_unitary(self, op: cirq.Operation):
         ch_form_args = clifford.StabilizerChFormSimulationState(
             prng=np.random.RandomState(), qubits=self.qubit_map.keys(), initial_state=self.ch_form
         )
@@ -253,7 +255,7 @@ class CliffordState:
 
     def apply_measurement(
         self,
-        op: 'cirq.Operation',
+        op: cirq.Operation,
         measurements: Dict[str, List[int]],
         prng: np.random.RandomState,
         collapse_state_vector=True,

cirq/sim/clifford/clifford_tableau_simulation_state.py

@@ -11,9 +11,12 @@
 # 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 protocol for implementing high performance clifford tableau evolutions
 for Clifford Simulator."""
 
+from __future__ import annotations
+
 from typing import Optional, Sequence, TYPE_CHECKING
 
 import numpy as np
@@ -30,10 +33,10 @@ class CliffordTableauSimulationState(StabilizerSimulationState[clifford_tableau.
 
     def __init__(
         self,
-        tableau: 'cirq.CliffordTableau',
+        tableau: cirq.CliffordTableau,
         prng: Optional[np.random.RandomState] = None,
-        qubits: Optional[Sequence['cirq.Qid']] = None,
-        classical_data: Optional['cirq.ClassicalDataStore'] = None,
+        qubits: Optional[Sequence[cirq.Qid]] = None,
+        classical_data: Optional[cirq.ClassicalDataStore] = None,
     ):
         """Inits CliffordTableauSimulationState.
 
@@ -51,5 +54,5 @@ class CliffordTableauSimulationState(StabilizerSimulationState[clifford_tableau.
         super().__init__(state=tableau, prng=prng, qubits=qubits, classical_data=classical_data)
 
     @property
-    def tableau(self) -> 'cirq.CliffordTableau':
+    def tableau(self) -> cirq.CliffordTableau:
         return self.state

cirq/sim/clifford/stabilizer_ch_form_simulation_state.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 Optional, Sequence, TYPE_CHECKING, Union
 
 import numpy as np
@@ -33,9 +35,9 @@ class StabilizerChFormSimulationState(
         self,
         *,
         prng: Optional[np.random.RandomState] = None,
-        qubits: Optional[Sequence['cirq.Qid']] = None,
-        initial_state: Union[int, 'cirq.StabilizerStateChForm'] = 0,
-        classical_data: Optional['cirq.ClassicalDataStore'] = None,
+        qubits: Optional[Sequence[cirq.Qid]] = None,
+        initial_state: Union[int, cirq.StabilizerStateChForm] = 0,
+        classical_data: Optional[cirq.ClassicalDataStore] = None,
     ):
         """Initializes with the given state and the axes for the operation.
 

cirq/sim/clifford/stabilizer_sampler.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 Dict, List, Sequence
 
 import numpy as np
@@ -26,7 +28,7 @@ from cirq.work import sampler
 class StabilizerSampler(sampler.Sampler):
     """An efficient sampler for stabilizer circuits."""
 
-    def __init__(self, *, seed: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None):
+    def __init__(self, *, seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None):
         """Inits StabilizerSampler.
 
         Args:
@@ -36,8 +38,8 @@ class StabilizerSampler(sampler.Sampler):
         self._prng = value.parse_random_state(seed)
 
     def run_sweep(
-        self, program: 'cirq.AbstractCircuit', params: 'cirq.Sweepable', repetitions: int = 1
-    ) -> Sequence['cirq.Result']:
+        self, program: cirq.AbstractCircuit, params: cirq.Sweepable, repetitions: int = 1
+    ) -> Sequence[cirq.Result]:
         results: List[cirq.Result] = []
         for param_resolver in cirq.to_resolvers(params):
             resolved_circuit = cirq.resolve_parameters(program, param_resolver)
@@ -45,7 +47,7 @@ class StabilizerSampler(sampler.Sampler):
             results.append(cirq.ResultDict(params=param_resolver, measurements=measurements))
         return results
 
-    def _run(self, circuit: 'cirq.AbstractCircuit', repetitions: int) -> Dict[str, np.ndarray]:
+    def _run(self, circuit: cirq.AbstractCircuit, repetitions: int) -> Dict[str, np.ndarray]:
 
         measurements: Dict[str, List[np.ndarray]] = {
             key: [] for key in protocols.measurement_key_names(circuit)

cirq/sim/clifford/stabilizer_simulation_state.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 types import NotImplementedType
 from typing import Any, cast, Generic, Optional, Sequence, TYPE_CHECKING, TypeVar, Union
@@ -42,8 +44,8 @@ class StabilizerSimulationState(
         *,
         state: TStabilizerState,
         prng: Optional[np.random.RandomState] = None,
-        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 StabilizerSimulationState.
 
@@ -65,7 +67,7 @@ class StabilizerSimulationState(
         return self._state
 
     def _act_on_fallback_(
-        self, action: Any, qubits: Sequence['cirq.Qid'], allow_decompose: bool = True
+        self, action: Any, qubits: Sequence[cirq.Qid], allow_decompose: bool = True
     ) -> Union[bool, NotImplementedType]:
         strats = [self._strat_apply_gate, self._strat_apply_mixture]
         if allow_decompose:
@@ -89,7 +91,7 @@ class StabilizerSimulationState(
         self._state.apply_cx(target_axis, control_axis, exponent, global_shift)
         self._state.apply_cx(control_axis, target_axis)
 
-    def _strat_apply_gate(self, val: Any, qubits: Sequence['cirq.Qid']) -> bool:
+    def _strat_apply_gate(self, val: Any, qubits: Sequence[cirq.Qid]) -> bool:
         if not protocols.has_stabilizer_effect(val):
             return NotImplemented
         gate = val.gate if isinstance(val, ops.Operation) else val
@@ -117,7 +119,7 @@ class StabilizerSimulationState(
             return NotImplemented
         return True
 
-    def _strat_apply_mixture(self, val: Any, qubits: Sequence['cirq.Qid']) -> bool:
+    def _strat_apply_mixture(self, val: Any, qubits: Sequence[cirq.Qid]) -> bool:
         mixture = protocols.mixture(val, None)
         if mixture is None:
             return NotImplemented
@@ -129,9 +131,7 @@ class StabilizerSimulationState(
             matrix_gates.MatrixGate(unitaries[index]), qubits
         )
 
-    def _strat_act_from_single_qubit_decompose(
-        self, val: Any, qubits: Sequence['cirq.Qid']
-    ) -> bool:
+    def _strat_act_from_single_qubit_decompose(self, val: Any, qubits: Sequence[cirq.Qid]) -> bool:
         if num_qubits(val) == 1:
             if not has_unitary(val):
                 return NotImplemented
@@ -148,7 +148,7 @@ class StabilizerSimulationState(
 
         return NotImplemented
 
-    def _strat_decompose(self, val: Any, qubits: Sequence['cirq.Qid']) -> bool:
+    def _strat_decompose(self, val: Any, qubits: Sequence[cirq.Qid]) -> bool:
         gate = val.gate if isinstance(val, ops.Operation) else val
         operations = protocols.decompose_once_with_qubits(gate, qubits, None)
         if operations is None or not all(protocols.has_stabilizer_effect(op) for op in operations):

cirq/sim/clifford/stabilizer_state_ch_form.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, Dict, List, Sequence
 
 import numpy as np
@@ -81,7 +83,7 @@ class StabilizerStateChForm(qis.StabilizerState):
     def _value_equality_values_(self) -> Any:
         return (self.n, self.G, self.F, self.M, self.gamma, self.v, self.s, self.omega)
 
-    def copy(self, deep_copy_buffers: bool = True) -> 'cirq.StabilizerStateChForm':
+    def copy(self, deep_copy_buffers: bool = True) -> cirq.StabilizerStateChForm:
         copy = StabilizerStateChForm(self.n)
 
         copy.G = self.G.copy()
@@ -267,7 +269,7 @@ class StabilizerStateChForm(qis.StabilizerState):
 
         self.update_sum(t, u, delta=delta)
 
-    def kron(self, other: 'cirq.StabilizerStateChForm') -> 'cirq.StabilizerStateChForm':
+    def kron(self, other: cirq.StabilizerStateChForm) -> cirq.StabilizerStateChForm:
         n = self.n + other.n
         copy = StabilizerStateChForm(n)
         copy.G[: self.n, : self.n] = self.G
@@ -282,7 +284,7 @@ class StabilizerStateChForm(qis.StabilizerState):
         copy.omega = self.omega * other.omega
         return copy
 
-    def reindex(self, axes: Sequence[int]) -> 'cirq.StabilizerStateChForm':
+    def reindex(self, axes: Sequence[int]) -> cirq.StabilizerStateChForm:
         copy = StabilizerStateChForm(self.n)
         copy.G = self.G[axes][:, axes]
         copy.F = self.F[axes][:, axes]
@@ -387,7 +389,7 @@ class StabilizerStateChForm(qis.StabilizerState):
         self.omega *= coefficient
 
     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/sim/density_matrix_simulation_state.py

@@ -14,6 +14,8 @@
 
 """Objects and methods for acting efficiently on a density matrix."""
 
+from __future__ import annotations
+
 from typing import Any, Callable, List, Optional, Sequence, Tuple, Type, TYPE_CHECKING, Union
 
 import numpy as np
@@ -55,7 +57,7 @@ class _BufferedDensityMatrix(qis.QuantumStateRepresentation):
     def create(
         cls,
         *,
-        initial_state: Union[np.ndarray, 'cirq.STATE_VECTOR_LIKE'] = 0,
+        initial_state: Union[np.ndarray, cirq.STATE_VECTOR_LIKE] = 0,
         qid_shape: Optional[Tuple[int, ...]] = None,
         dtype: Optional[Type[np.complexfloating]] = None,
         buffer: Optional[List[np.ndarray]] = None,
@@ -91,7 +93,7 @@ class _BufferedDensityMatrix(qis.QuantumStateRepresentation):
         density_matrix = density_matrix.astype(dtype, copy=False)
         return cls(density_matrix, buffer)
 
-    def copy(self, deep_copy_buffers: bool = True) -> '_BufferedDensityMatrix':
+    def copy(self, deep_copy_buffers: bool = True) -> _BufferedDensityMatrix:
         """Copies the object.
 
         Args:
@@ -104,7 +106,7 @@ class _BufferedDensityMatrix(qis.QuantumStateRepresentation):
             buffer=[b.copy() for b in self._buffer] if deep_copy_buffers else self._buffer,
         )
 
-    def kron(self, other: '_BufferedDensityMatrix') -> '_BufferedDensityMatrix':
+    def kron(self, other: _BufferedDensityMatrix) -> _BufferedDensityMatrix:
         """Creates the Kronecker product with the other density matrix.
 
         Args:
@@ -119,7 +121,7 @@ class _BufferedDensityMatrix(qis.QuantumStateRepresentation):
 
     def factor(
         self, axes: Sequence[int], *, validate=True, atol=1e-07
-    ) -> Tuple['_BufferedDensityMatrix', '_BufferedDensityMatrix']:
+    ) -> Tuple[_BufferedDensityMatrix, _BufferedDensityMatrix]:
         """Factors out the desired axes.
 
         Args:
@@ -141,7 +143,7 @@ class _BufferedDensityMatrix(qis.QuantumStateRepresentation):
         remainder = _BufferedDensityMatrix(density_matrix=remainder_tensor)
         return extracted, remainder
 
-    def reindex(self, axes: Sequence[int]) -> '_BufferedDensityMatrix':
+    def reindex(self, axes: Sequence[int]) -> _BufferedDensityMatrix:
         """Transposes the axes of a density matrix to a specified order.
 
         Args:
@@ -185,7 +187,7 @@ class _BufferedDensityMatrix(qis.QuantumStateRepresentation):
         return True
 
     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.
 
@@ -205,10 +207,7 @@ class _BufferedDensityMatrix(qis.QuantumStateRepresentation):
         return bits
 
     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 density matrix.
 
@@ -248,10 +247,10 @@ class DensityMatrixSimulationState(SimulationState[_BufferedDensityMatrix]):
         *,
         available_buffer: Optional[List[np.ndarray]] = None,
         prng: Optional[np.random.RandomState] = None,
-        qubits: Optional[Sequence['cirq.Qid']] = None,
-        initial_state: Union[np.ndarray, 'cirq.STATE_VECTOR_LIKE'] = 0,
+        qubits: Optional[Sequence[cirq.Qid]] = None,
+        initial_state: Union[np.ndarray, cirq.STATE_VECTOR_LIKE] = 0,
         dtype: Type[np.complexfloating] = np.complex64,
-        classical_data: Optional['cirq.ClassicalDataStore'] = None,
+        classical_data: Optional[cirq.ClassicalDataStore] = None,
     ):
         """Inits DensityMatrixSimulationState.
 
@@ -285,7 +284,7 @@ class DensityMatrixSimulationState(SimulationState[_BufferedDensityMatrix]):
         )
         super().__init__(state=state, prng=prng, qubits=qubits, classical_data=classical_data)
 
-    def add_qubits(self, qubits: Sequence['cirq.Qid']):
+    def add_qubits(self, qubits: Sequence[cirq.Qid]):
         ret = super().add_qubits(qubits)
         return (
             self.kronecker_product(type(self)(qubits=qubits), inplace=True)
@@ -293,7 +292,7 @@ class DensityMatrixSimulationState(SimulationState[_BufferedDensityMatrix]):
             else ret
         )
 
-    def remove_qubits(self, qubits: Sequence['cirq.Qid']):
+    def remove_qubits(self, qubits: Sequence[cirq.Qid]):
         ret = super().remove_qubits(qubits)
         if ret is not NotImplemented:
             return ret
@@ -302,9 +301,9 @@ class DensityMatrixSimulationState(SimulationState[_BufferedDensityMatrix]):
         return remainder
 
     def _act_on_fallback_(
-        self, action: Any, qubits: Sequence['cirq.Qid'], allow_decompose: bool = True
+        self, action: Any, qubits: Sequence[cirq.Qid], allow_decompose: bool = True
     ) -> bool:
-        strats: List[Callable[[Any, Any, Sequence['cirq.Qid']], bool]] = [
+        strats: List[Callable[[Any, Any, Sequence[cirq.Qid]], bool]] = [
             _strat_apply_channel_to_state
         ]
         if allow_decompose:
@@ -346,7 +345,7 @@ class DensityMatrixSimulationState(SimulationState[_BufferedDensityMatrix]):
 
 
 def _strat_apply_channel_to_state(
-    action: Any, args: 'cirq.DensityMatrixSimulationState', qubits: Sequence['cirq.Qid']
+    action: Any, args: cirq.DensityMatrixSimulationState, qubits: Sequence[cirq.Qid]
 ) -> bool:
     """Apply channel to state."""
     if not args._state.apply_channel(action, args.get_axes(qubits)):

cirq/sim/density_matrix_simulator.py

@@ -11,7 +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.
+
 """Simulator for density matrices that simulates noisy quantum circuits."""
+
+from __future__ import annotations
+
 from typing import Any, Dict, List, Optional, Sequence, Type, TYPE_CHECKING, Union
 
 import numpy as np
@@ -116,8 +120,8 @@ class DensityMatrixSimulator(
         self,
         *,
         dtype: Type[np.complexfloating] = np.complex64,
-        noise: 'cirq.NOISE_MODEL_LIKE' = None,
-        seed: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None,
+        noise: cirq.NOISE_MODEL_LIKE = None,
+        seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
         split_untangled_states: bool = True,
     ):
         """Density matrix simulator.
@@ -147,12 +151,10 @@ class DensityMatrixSimulator(
 
     def _create_partial_simulation_state(
         self,
-        initial_state: Union[
-            np.ndarray, 'cirq.STATE_VECTOR_LIKE', 'cirq.DensityMatrixSimulationState'
-        ],
-        qubits: Sequence['cirq.Qid'],
-        classical_data: 'cirq.ClassicalDataStore',
-    ) -> 'cirq.DensityMatrixSimulationState':
+        initial_state: Union[np.ndarray, cirq.STATE_VECTOR_LIKE, cirq.DensityMatrixSimulationState],
+        qubits: Sequence[cirq.Qid],
+        classical_data: cirq.ClassicalDataStore,
+    ) -> cirq.DensityMatrixSimulationState:
         """Creates the DensityMatrixSimulationState for a circuit.
 
         Args:
@@ -183,16 +185,16 @@ class DensityMatrixSimulator(
         return not protocols.measurement_keys_touched(val)
 
     def _create_step_result(
-        self, sim_state: 'cirq.SimulationStateBase[cirq.DensityMatrixSimulationState]'
+        self, sim_state: cirq.SimulationStateBase[cirq.DensityMatrixSimulationState]
     ):
         return DensityMatrixStepResult(sim_state=sim_state, dtype=self._dtype)
 
     def _create_simulator_trial_result(
         self,
-        params: 'cirq.ParamResolver',
+        params: cirq.ParamResolver,
         measurements: Dict[str, np.ndarray],
-        final_simulator_state: 'cirq.SimulationStateBase[cirq.DensityMatrixSimulationState]',
-    ) -> 'cirq.DensityMatrixTrialResult':
+        final_simulator_state: cirq.SimulationStateBase[cirq.DensityMatrixSimulationState],
+    ) -> cirq.DensityMatrixTrialResult:
         return DensityMatrixTrialResult(
             params=params, measurements=measurements, final_simulator_state=final_simulator_state
         )
@@ -200,10 +202,10 @@ class DensityMatrixSimulator(
     # TODO(#4209): Deduplicate with identical code in sparse_simulator.
     def simulate_expectation_values_sweep(
         self,
-        program: 'cirq.AbstractCircuit',
-        observables: Union['cirq.PauliSumLike', List['cirq.PauliSumLike']],
-        params: 'cirq.Sweepable',
-        qubit_order: 'cirq.QubitOrderOrList' = ops.QubitOrder.DEFAULT,
+        program: cirq.AbstractCircuit,
+        observables: Union[cirq.PauliSumLike, List[cirq.PauliSumLike]],
+        params: cirq.Sweepable,
+        qubit_order: cirq.QubitOrderOrList = ops.QubitOrder.DEFAULT,
         initial_state: Any = None,
         permit_terminal_measurements: bool = False,
     ) -> List[List[float]]:
@@ -242,7 +244,7 @@ class DensityMatrixStepResult(simulator_base.StepResultBase['cirq.DensityMatrixS
 
     def __init__(
         self,
-        sim_state: 'cirq.SimulationStateBase[cirq.DensityMatrixSimulationState]',
+        sim_state: cirq.SimulationStateBase[cirq.DensityMatrixSimulationState],
         dtype: Type[np.complexfloating] = np.complex64,
     ):
         """DensityMatrixStepResult.
@@ -353,9 +355,9 @@ class DensityMatrixTrialResult(
 
     def __init__(
         self,
-        params: 'cirq.ParamResolver',
+        params: cirq.ParamResolver,
         measurements: Dict[str, np.ndarray],
-        final_simulator_state: 'cirq.SimulationStateBase[cirq.DensityMatrixSimulationState]',
+        final_simulator_state: cirq.SimulationStateBase[cirq.DensityMatrixSimulationState],
     ) -> None:
         super().__init__(
             params=params, measurements=measurements, final_simulator_state=final_simulator_state

cirq/sim/density_matrix_utils.py

@@ -14,6 +14,8 @@
 
 """Code to handle density matrices."""
 
+from __future__ import annotations
+
 from typing import List, Optional, Sequence, Tuple, TYPE_CHECKING
 
 import numpy as np
@@ -31,7 +33,7 @@ def sample_density_matrix(
     *,  # Force keyword arguments
     qid_shape: Optional[Tuple[int, ...]] = None,
     repetitions: int = 1,
-    seed: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None,
+    seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
 ) -> np.ndarray:
     """Samples repeatedly from measurements in the computational basis.
 
@@ -96,7 +98,7 @@ def measure_density_matrix(
     indices: Sequence[int],
     qid_shape: Optional[Tuple[int, ...]] = None,
     out: Optional[np.ndarray] = None,
-    seed: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None,
+    seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
 ) -> Tuple[List[int], np.ndarray]:
     """Performs a measurement of the density matrix in the computational basis.