cirq-core 1.5.0.dev20250403170622__py3-none-any.whl → 1.5.0.dev20250404021339__py3-none-any.whl

cirq/contrib/bayesian_network/bayesian_network_gate.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import math
 from typing import Any, cast, Dict, Iterator, List, Optional, Sequence, Tuple, TYPE_CHECKING, Union
 
@@ -158,7 +160,7 @@ class BayesianNetworkGate(raw_types.Gate):
                     raise ValueError('Conditional prob should be between 0 and 1.')
         self._arc_probs = arc_probs
 
-    def _decompose_(self, qubits: Sequence['raw_types.Qid']) -> Iterator['cirq.OP_TREE']:
+    def _decompose_(self, qubits: Sequence[cirq.Qid]) -> Iterator[cirq.OP_TREE]:
         parameter_names = [init_prob[0] for init_prob in self._init_probs]
         qubit_map = dict(zip(parameter_names, qubits))
 
@@ -188,7 +190,7 @@ class BayesianNetworkGate(raw_types.Gate):
         init_probs: List[List[Union[str, Optional[float]]]],
         arc_probs: List[List[Union[str, List[str], List[float]]]],
         **kwargs,
-    ) -> 'BayesianNetworkGate':
+    ) -> BayesianNetworkGate:
         converted_init_probs = cast(
             List[Tuple[str, Optional[float]]],
             [(param, init_prob) for param, init_prob in init_probs],

cirq/contrib/circuitdag/circuit_dag.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import functools
 from typing import Any, Callable, cast, Dict, Generic, Iterator, TypeVar
 
@@ -48,7 +50,7 @@ class Unique(Generic[T]):
         return id(self) < id(other)
 
 
-def _disjoint_qubits(op1: 'cirq.Operation', op2: 'cirq.Operation') -> bool:
+def _disjoint_qubits(op1: cirq.Operation, op2: cirq.Operation) -> bool:
     """Returns true only if the operations have qubits in common."""
     return not set(op1.qubits) & set(op2.qubits)
 
@@ -70,7 +72,7 @@ class CircuitDag(networkx.DiGraph):
 
     def __init__(
         self,
-        can_reorder: Callable[['cirq.Operation', 'cirq.Operation'], bool] = _disjoint_qubits,
+        can_reorder: Callable[[cirq.Operation, cirq.Operation], bool] = _disjoint_qubits,
         incoming_graph_data: Any = None,
     ) -> None:
         """Initializes a CircuitDag.
@@ -91,27 +93,27 @@ class CircuitDag(networkx.DiGraph):
         self.can_reorder = can_reorder
 
     @staticmethod
-    def make_node(op: 'cirq.Operation') -> Unique:
+    def make_node(op: cirq.Operation) -> Unique:
         return Unique(op)
 
     @staticmethod
     def from_circuit(
         circuit: cirq.Circuit,
-        can_reorder: Callable[['cirq.Operation', 'cirq.Operation'], bool] = _disjoint_qubits,
-    ) -> 'CircuitDag':
+        can_reorder: Callable[[cirq.Operation, cirq.Operation], bool] = _disjoint_qubits,
+    ) -> CircuitDag:
         return CircuitDag.from_ops(circuit.all_operations(), can_reorder=can_reorder)
 
     @staticmethod
     def from_ops(
-        *operations: 'cirq.OP_TREE',
-        can_reorder: Callable[['cirq.Operation', 'cirq.Operation'], bool] = _disjoint_qubits,
-    ) -> 'CircuitDag':
+        *operations: cirq.OP_TREE,
+        can_reorder: Callable[[cirq.Operation, cirq.Operation], bool] = _disjoint_qubits,
+    ) -> CircuitDag:
         dag = CircuitDag(can_reorder=can_reorder)
         for op in ops.flatten_op_tree(operations):
             dag.append(cast(ops.Operation, op))
         return dag
 
-    def append(self, op: 'cirq.Operation') -> None:
+    def append(self, op: cirq.Operation) -> None:
         new_node = self.make_node(op)
         for node in list(self.nodes()):
             if not self.can_reorder(node.val, op):
@@ -140,21 +142,21 @@ class CircuitDag(networkx.DiGraph):
 
     __hash__ = None  # type: ignore
 
-    def ordered_nodes(self) -> Iterator[Unique['cirq.Operation']]:
+    def ordered_nodes(self) -> Iterator[Unique[cirq.Operation]]:
         if not self.nodes():
             return
         g = self.copy()
 
-        def get_root_node(some_node: Unique['cirq.Operation']) -> Unique['cirq.Operation']:
+        def get_root_node(some_node: Unique[cirq.Operation]) -> Unique[cirq.Operation]:
             pred = g.pred
             while pred[some_node]:
                 some_node = next(iter(pred[some_node]))
             return some_node
 
-        def get_first_node() -> Unique['cirq.Operation']:
+        def get_first_node() -> Unique[cirq.Operation]:
             return get_root_node(next(iter(g.nodes())))
 
-        def get_next_node(succ: networkx.classes.coreviews.AtlasView) -> Unique['cirq.Operation']:
+        def get_next_node(succ: networkx.classes.coreviews.AtlasView) -> Unique[cirq.Operation]:
             if succ:
                 return get_root_node(next(iter(succ)))
 
@@ -171,7 +173,7 @@ class CircuitDag(networkx.DiGraph):
 
             node = get_next_node(succ)
 
-    def all_operations(self) -> Iterator['cirq.Operation']:
+    def all_operations(self) -> Iterator[cirq.Operation]:
         return (node.val for node in self.ordered_nodes())
 
     def all_qubits(self):
@@ -181,8 +183,8 @@ class CircuitDag(networkx.DiGraph):
         return cirq.Circuit(self.all_operations(), strategy=cirq.InsertStrategy.EARLIEST)
 
     def findall_nodes_until_blocked(
-        self, is_blocker: Callable[['cirq.Operation'], bool]
-    ) -> Iterator[Unique['cirq.Operation']]:
+        self, is_blocker: Callable[[cirq.Operation], bool]
+    ) -> Iterator[Unique[cirq.Operation]]:
         """Finds all nodes before blocking ones.
 
         Args:

cirq/contrib/custom_simulators/custom_state_simulator.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, Generic, Sequence, Type, TYPE_CHECKING
 
 import numpy as np
@@ -47,7 +49,7 @@ class CustomStateSimulator(
         self,
         state_type: Type[TSimulationState],
         *,
-        noise: 'cirq.NOISE_MODEL_LIKE' = None,
+        noise: cirq.NOISE_MODEL_LIKE = None,
         split_untangled_states: bool = False,
     ):
         """Initializes a CustomStateSimulator.
@@ -63,24 +65,24 @@ class CustomStateSimulator(
 
     def _create_simulator_trial_result(
         self,
-        params: 'cirq.ParamResolver',
+        params: cirq.ParamResolver,
         measurements: Dict[str, np.ndarray],
-        final_simulator_state: 'cirq.SimulationStateBase[TSimulationState]',
-    ) -> 'CustomStateTrialResult[TSimulationState]':
+        final_simulator_state: cirq.SimulationStateBase[TSimulationState],
+    ) -> CustomStateTrialResult[TSimulationState]:
         return CustomStateTrialResult(
             params, measurements, final_simulator_state=final_simulator_state
         )
 
     def _create_step_result(
-        self, sim_state: 'cirq.SimulationStateBase[TSimulationState]'
-    ) -> 'CustomStateStepResult[TSimulationState]':
+        self, sim_state: cirq.SimulationStateBase[TSimulationState]
+    ) -> CustomStateStepResult[TSimulationState]:
         return CustomStateStepResult(sim_state)
 
     def _create_partial_simulation_state(
         self,
         initial_state: Any,
-        qubits: Sequence['cirq.Qid'],
-        classical_data: 'cirq.ClassicalDataStore',
+        qubits: Sequence[cirq.Qid],
+        classical_data: cirq.ClassicalDataStore,
     ) -> TSimulationState:
         return self.state_type(
             initial_state=initial_state, qubits=qubits, classical_data=classical_data

cirq/contrib/custom_simulators/custom_state_simulator_test.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 List, Sequence, Tuple
 
 import numpy as np
@@ -25,10 +27,10 @@ class ComputationalBasisState(cirq.qis.QuantumStateRepresentation):
     def __init__(self, initial_state: List[int]):
         self.basis = initial_state
 
-    def copy(self, deep_copy_buffers: bool = True) -> 'ComputationalBasisState':
+    def copy(self, deep_copy_buffers: bool = True) -> ComputationalBasisState:
         return ComputationalBasisState(self.basis)  # pragma: no cover
 
-    def measure(self, axes: Sequence[int], seed: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None):
+    def measure(self, axes: Sequence[int], seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None):
         return [self.basis[i] for i in axes]
 
 
@@ -137,18 +139,18 @@ class ComputationalBasisProductState(cirq.qis.QuantumStateRepresentation):
     def __init__(self, initial_state: List[int]):
         self.basis = initial_state
 
-    def copy(self, deep_copy_buffers: bool = True) -> 'ComputationalBasisProductState':
+    def copy(self, deep_copy_buffers: bool = True) -> ComputationalBasisProductState:
         return ComputationalBasisProductState(self.basis)
 
-    def measure(self, axes: Sequence[int], seed: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None):
+    def measure(self, axes: Sequence[int], seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None):
         return [self.basis[i] for i in axes]
 
-    def kron(self, other: 'ComputationalBasisProductState') -> 'ComputationalBasisProductState':
+    def kron(self, other: ComputationalBasisProductState) -> ComputationalBasisProductState:
         return ComputationalBasisProductState(self.basis + other.basis)
 
     def factor(
         self, axes: Sequence[int], *, validate=True, atol=1e-07
-    ) -> Tuple['ComputationalBasisProductState', 'ComputationalBasisProductState']:
+    ) -> Tuple[ComputationalBasisProductState, ComputationalBasisProductState]:
         extracted = ComputationalBasisProductState(
             [self.basis[i] for i in axes]
         )  # pragma: no cover
@@ -157,7 +159,7 @@ class ComputationalBasisProductState(cirq.qis.QuantumStateRepresentation):
         )  # pragma: no cover
         return extracted, remainder  # pragma: no cover
 
-    def reindex(self, axes: Sequence[int]) -> 'ComputationalBasisProductState':
+    def reindex(self, axes: Sequence[int]) -> ComputationalBasisProductState:
         return ComputationalBasisProductState([self.basis[i] for i in axes])
 
     @property

cirq/contrib/graph_device/graph_device.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 itertools
 from typing import cast, Iterable, Optional, Tuple, TYPE_CHECKING
@@ -150,7 +152,7 @@ class UndirectedGraphDevice(devices.Device):
         self.crosstalk_graph = crosstalk_graph
 
     @property
-    def qubits(self) -> Tuple['cirq.Qid', ...]:
+    def qubits(self) -> Tuple[cirq.Qid, ...]:
         return cast(Tuple['cirq.Qid', ...], tuple(sorted(self.device_graph.vertices)))
 
     @property
@@ -192,7 +194,7 @@ class UndirectedGraphDevice(devices.Device):
             ):
                 validator(operation, *crosstalk_operations)
 
-    def validate_moment(self, moment: 'cirq.Moment'):
+    def validate_moment(self, moment: cirq.Moment):
         super().validate_moment(moment)
         ops = moment.operations
         for i, op in enumerate(ops):

cirq/contrib/noise_models/noise_models.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 Sequence, TYPE_CHECKING
 
 from cirq import circuits, devices, ops, value
@@ -40,7 +42,7 @@ class DepolarizingNoiseModel(devices.NoiseModel):
         self.qubit_noise_gate = ops.DepolarizingChannel(depol_prob)
         self._prepend = prepend
 
-    def noisy_moment(self, moment: 'cirq.Moment', system_qubits: Sequence['cirq.Qid']):
+    def noisy_moment(self, moment: cirq.Moment, system_qubits: Sequence[cirq.Qid]):
         if validate_all_measurements(moment) or self.is_virtual_moment(moment):  # pragma: no cover
             return moment
 
@@ -76,7 +78,7 @@ class ReadoutNoiseModel(devices.NoiseModel):
         self.readout_noise_gate = ops.BitFlipChannel(bitflip_prob)
         self._prepend = prepend
 
-    def noisy_moment(self, moment: 'cirq.Moment', system_qubits: Sequence['cirq.Qid']):
+    def noisy_moment(self, moment: cirq.Moment, system_qubits: Sequence[cirq.Qid]):
         if self.is_virtual_moment(moment):
             return moment
         if validate_all_measurements(moment):
@@ -113,7 +115,7 @@ class DampedReadoutNoiseModel(devices.NoiseModel):
         self.readout_decay_gate = ops.AmplitudeDampingChannel(decay_prob)
         self._prepend = prepend
 
-    def noisy_moment(self, moment: 'cirq.Moment', system_qubits: Sequence['cirq.Qid']):
+    def noisy_moment(self, moment: cirq.Moment, system_qubits: Sequence[cirq.Qid]):
         if self.is_virtual_moment(moment):
             return moment
         if validate_all_measurements(moment):
@@ -146,7 +148,7 @@ class DepolarizingWithReadoutNoiseModel(devices.NoiseModel):
         self.qubit_noise_gate = ops.DepolarizingChannel(depol_prob)
         self.readout_noise_gate = ops.BitFlipChannel(bitflip_prob)
 
-    def noisy_moment(self, moment: 'cirq.Moment', system_qubits: Sequence['cirq.Qid']):
+    def noisy_moment(self, moment: cirq.Moment, system_qubits: Sequence[cirq.Qid]):
         if validate_all_measurements(moment):
             return [circuits.Moment(self.readout_noise_gate(q) for q in system_qubits), moment]
         return [moment, circuits.Moment(self.qubit_noise_gate(q) for q in system_qubits)]
@@ -176,7 +178,7 @@ class DepolarizingWithDampedReadoutNoiseModel(devices.NoiseModel):
         self.readout_noise_gate = ops.BitFlipChannel(bitflip_prob)
         self.readout_decay_gate = ops.AmplitudeDampingChannel(decay_prob)
 
-    def noisy_moment(self, moment: 'cirq.Moment', system_qubits: Sequence['cirq.Qid']):
+    def noisy_moment(self, moment: cirq.Moment, system_qubits: Sequence[cirq.Qid]):
         if validate_all_measurements(moment):
             return [
                 circuits.Moment(self.readout_decay_gate(q) for q in system_qubits),

cirq/contrib/paulistring/clifford_target_gateset.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 from enum import Enum
 from types import NotImplementedType
 from typing import cast, List, Type, TYPE_CHECKING, Union
@@ -25,7 +27,7 @@ if TYPE_CHECKING:
 
 
 def _matrix_to_clifford_op(
-    mat: np.ndarray, qubit: 'cirq.Qid', *, atol: float
+    mat: np.ndarray, qubit: cirq.Qid, *, atol: float
 ) -> Union[ops.Operation, NotImplementedType]:
     rotations = transformers.single_qubit_matrix_to_pauli_rotations(mat, atol)
     clifford_gate = ops.SingleQubitCliffordGate.I
@@ -43,7 +45,7 @@ def _matrix_to_clifford_op(
 
 
 def _matrix_to_pauli_string_phasors(
-    mat: np.ndarray, qubit: 'cirq.Qid', *, keep_clifford: bool, atol: float
+    mat: np.ndarray, qubit: cirq.Qid, *, keep_clifford: bool, atol: float
 ) -> ops.OP_TREE:
     rotations = transformers.single_qubit_matrix_to_pauli_rotations(mat, atol)
     out_ops: List[ops.GateOperation] = []
@@ -95,7 +97,7 @@ class CliffordTargetGateset(transformers.TwoQubitCompilationTargetGateset):
         """
         self.atol = atol
         self.single_qubit_target = single_qubit_target
-        gates: List[Union['cirq.Gate', Type['cirq.Gate']]] = [ops.CZ, ops.MeasurementGate]
+        gates: List[Union[cirq.Gate, Type[cirq.Gate]]] = [ops.CZ, ops.MeasurementGate]
         if single_qubit_target in [
             self.SingleQubitTarget.SINGLE_QUBIT_CLIFFORDS,
             self.SingleQubitTarget.PAULI_STRING_PHASORS_AND_CLIFFORDS,
@@ -109,8 +111,8 @@ class CliffordTargetGateset(transformers.TwoQubitCompilationTargetGateset):
         super().__init__(*gates)
 
     def _decompose_single_qubit_operation(
-        self, op: 'cirq.Operation', _
-    ) -> Union[NotImplementedType, 'cirq.OP_TREE']:
+        self, op: cirq.Operation, _
+    ) -> Union[NotImplementedType, cirq.OP_TREE]:
         if not protocols.has_unitary(op):
             return NotImplemented
         mat = protocols.unitary(op)
@@ -126,8 +128,8 @@ class CliffordTargetGateset(transformers.TwoQubitCompilationTargetGateset):
         )
 
     def _decompose_two_qubit_operation(
-        self, op: 'cirq.Operation', _
-    ) -> Union[NotImplementedType, 'cirq.OP_TREE']:
+        self, op: cirq.Operation, _
+    ) -> Union[NotImplementedType, cirq.OP_TREE]:
         if not protocols.has_unitary(op):
             return NotImplemented
         return transformers.two_qubit_matrix_to_cz_operations(
@@ -139,10 +141,10 @@ class CliffordTargetGateset(transformers.TwoQubitCompilationTargetGateset):
         )
 
     @property
-    def postprocess_transformers(self) -> List['cirq.TRANSFORMER']:
+    def postprocess_transformers(self) -> List[cirq.TRANSFORMER]:
         """List of transformers which should be run after decomposing individual operations."""
 
-        def rewriter(o: 'cirq.CircuitOperation'):
+        def rewriter(o: cirq.CircuitOperation):
             result = self._decompose_single_qubit_operation(o, -1)
             return o.circuit.all_operations() if result is NotImplemented else result
 

cirq/contrib/qcircuit/qcircuit_diagram.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
+
 from typing import TYPE_CHECKING
 
 from cirq import circuits, ops
@@ -23,7 +26,7 @@ if TYPE_CHECKING:
     import cirq
 
 
-def qcircuit_qubit_namer(qubit: 'cirq.Qid') -> str:
+def qcircuit_qubit_namer(qubit: cirq.Qid) -> str:
     """Returns the latex code for a QCircuit label of given qubit.
 
     Args:
@@ -64,7 +67,7 @@ def _render(diagram: circuits.TextDiagramDrawer) -> str:
 
 
 def circuit_to_latex_using_qcircuit(
-    circuit: 'cirq.Circuit', qubit_order: 'cirq.QubitOrderOrList' = ops.QubitOrder.DEFAULT
+    circuit: cirq.Circuit, qubit_order: cirq.QubitOrderOrList = ops.QubitOrder.DEFAULT
 ) -> str:
     """Returns a QCircuit-based latex diagram of the given circuit.
 

cirq/contrib/quantum_volume/quantum_volume.py

@@ -15,7 +15,7 @@ import cirq.contrib.routing as ccr
 
 
 def generate_model_circuit(
-    num_qubits: int, depth: int, *, random_state: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None
+    num_qubits: int, depth: int, *, random_state: cirq.RANDOM_STATE_OR_SEED_LIKE = None
 ) -> cirq.Circuit:
     """Generates a model circuit with the given number of qubits and depth.
 
@@ -277,7 +277,7 @@ def compile_circuit(
     # Replace the PermutationGates with regular gates, so we don't proliferate
     # the routing implementation details to the compiler and the device itself.
 
-    def replace_swap_permutation_gate(op: 'cirq.Operation', _):
+    def replace_swap_permutation_gate(op: cirq.Operation, _):
         if isinstance(op.gate, cirq.contrib.acquaintance.SwapPermutationGate):
             return [op.gate.swap_gate.on(*op.qubits)]
         return op
@@ -327,7 +327,7 @@ def prepare_circuits(
     num_qubits: int,
     depth: int,
     num_circuits: int,
-    random_state: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None,
+    random_state: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
 ) -> List[Tuple[cirq.Circuit, List[int]]]:
     """Generates circuits and computes their heavy set.
 
@@ -423,7 +423,7 @@ def calculate_quantum_volume(
     num_circuits: int,
     device_graph: nx.Graph,
     samplers: List[cirq.Sampler],
-    random_state: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None,
+    random_state: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
     compiler: Optional[Callable[[cirq.Circuit], cirq.Circuit]] = None,
     repetitions=10_000,
     routing_attempts=30,

cirq/contrib/quimb/mps_simulator.py

@@ -17,6 +17,8 @@ This is based on this paper:
 https://arxiv.org/abs/2002.07730
 """
 
+from __future__ import annotations
+
 import dataclasses
 import math
 from typing import Any, Dict, List, Optional, Sequence, Set, Tuple, TYPE_CHECKING, Union
@@ -58,10 +60,10 @@ class MPSSimulator(
 
     def __init__(
         self,
-        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,
         simulation_options: MPSOptions = MPSOptions(),
-        grouping: Optional[Dict['cirq.Qid', int]] = None,
+        grouping: Optional[Dict[cirq.Qid, int]] = None,
     ):
         """Creates instance of `MPSSimulator`.
 
@@ -84,10 +86,10 @@ class MPSSimulator(
 
     def _create_partial_simulation_state(
         self,
-        initial_state: Union[int, 'MPSState'],
-        qubits: Sequence['cirq.Qid'],
-        classical_data: 'cirq.ClassicalDataStore',
-    ) -> 'MPSState':
+        initial_state: Union[int, MPSState],
+        qubits: Sequence[cirq.Qid],
+        classical_data: cirq.ClassicalDataStore,
+    ) -> MPSState:
         """Creates MPSState args for simulating the Circuit.
 
         Args:
@@ -114,15 +116,15 @@ class MPSSimulator(
             classical_data=classical_data,
         )
 
-    def _create_step_result(self, sim_state: 'cirq.SimulationStateBase[MPSState]'):
+    def _create_step_result(self, sim_state: cirq.SimulationStateBase[MPSState]):
         return MPSSimulatorStepResult(sim_state)
 
     def _create_simulator_trial_result(
         self,
-        params: 'cirq.ParamResolver',
+        params: cirq.ParamResolver,
         measurements: Dict[str, np.ndarray],
-        final_simulator_state: 'cirq.SimulationStateBase[MPSState]',
-    ) -> 'MPSTrialResult':
+        final_simulator_state: cirq.SimulationStateBase[MPSState],
+    ) -> MPSTrialResult:
         """Creates a single trial results with the measurements.
 
         Args:
@@ -144,16 +146,16 @@ class MPSTrialResult(simulator_base.SimulationTrialResultBase['MPSState']):
 
     def __init__(
         self,
-        params: 'cirq.ParamResolver',
+        params: cirq.ParamResolver,
         measurements: Dict[str, np.ndarray],
-        final_simulator_state: 'cirq.SimulationStateBase[MPSState]',
+        final_simulator_state: cirq.SimulationStateBase[MPSState],
     ) -> None:
         super().__init__(
             params=params, measurements=measurements, final_simulator_state=final_simulator_state
         )
 
     @property
-    def final_state(self) -> 'MPSState':
+    def final_state(self) -> MPSState:
         return self._get_merged_sim_state()
 
     def __str__(self) -> str:
@@ -173,7 +175,7 @@ class MPSTrialResult(simulator_base.SimulationTrialResultBase['MPSState']):
 class MPSSimulatorStepResult(simulator_base.StepResultBase['MPSState']):
     """A `StepResult` that can perform measurements."""
 
-    def __init__(self, sim_state: 'cirq.SimulationStateBase[MPSState]'):
+    def __init__(self, sim_state: cirq.SimulationStateBase[MPSState]):
         """Results of a step of the simulator.
         Attributes:
             sim_state: The qubit:SimulationState lookup for this step.
@@ -309,7 +311,7 @@ class _MPSHandler(qis.QuantumStateRepresentation):
     def _value_equality_values_(self) -> Any:
         return self._qid_shape, self._M, self._simulation_options, self._grouping
 
-    def copy(self, deep_copy_buffers: bool = True) -> '_MPSHandler':
+    def copy(self, deep_copy_buffers: bool = True) -> _MPSHandler:
         """Copies the object.
 
         Args:
@@ -520,7 +522,7 @@ class _MPSHandler(qis.QuantumStateRepresentation):
         return results
 
     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 MPS.
 
@@ -533,10 +535,7 @@ class _MPSHandler(qis.QuantumStateRepresentation):
         return self._measure(axes, value.parse_random_state(seed))
 
     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 MPS.
 
@@ -564,12 +563,12 @@ class MPSState(SimulationState[_MPSHandler]):
     def __init__(
         self,
         *,
-        qubits: Sequence['cirq.Qid'],
+        qubits: Sequence[cirq.Qid],
         prng: np.random.RandomState,
         simulation_options: MPSOptions = MPSOptions(),
-        grouping: Optional[Dict['cirq.Qid', int]] = None,
+        grouping: Optional[Dict[cirq.Qid, int]] = None,
         initial_state: int = 0,
-        classical_data: Optional['cirq.ClassicalDataStore'] = None,
+        classical_data: Optional[cirq.ClassicalDataStore] = None,
     ):
         """Creates and MPSState
 
@@ -623,7 +622,7 @@ class MPSState(SimulationState[_MPSHandler]):
         """
         return self._state.state_vector()
 
-    def partial_trace(self, keep_qubits: Set['cirq.Qid']) -> np.ndarray:
+    def partial_trace(self, keep_qubits: Set[cirq.Qid]) -> np.ndarray:
         """Traces out all qubits except keep_qubits.
 
         Args:
@@ -642,7 +641,7 @@ class MPSState(SimulationState[_MPSHandler]):
         return self._state.to_numpy()
 
     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:
         """Delegates the action to self.apply_op"""
         return self._state.apply_op(action, self.get_axes(qubits), self.prng)

cirq/contrib/routing/greedy.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import itertools
 from typing import (
     Callable,
@@ -109,7 +111,7 @@ class _GreedyRouter:
             op1.qubits
         )
         & set(op2.qubits),
-        random_state: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None,
+        random_state: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
     ):
 
         self.prng = value.parse_random_state(random_state)
@@ -148,12 +150,12 @@ class _GreedyRouter:
             ]
         return self.edge_sets[edge_set_size]
 
-    def log_to_phys(self, *qubits: 'cirq.Qid') -> Iterable[ops.Qid]:
+    def log_to_phys(self, *qubits: cirq.Qid) -> Iterable[ops.Qid]:
         """Returns an iterator over the physical qubits mapped to by the given
         logical qubits."""
         return (self._log_to_phys[q] for q in qubits)
 
-    def phys_to_log(self, *qubits: 'cirq.Qid') -> Iterable[Optional[ops.Qid]]:
+    def phys_to_log(self, *qubits: cirq.Qid) -> Iterable[Optional[ops.Qid]]:
         """Returns an iterator over the logical qubits that map to the given
         physical qubits."""
         return (self._phys_to_log[q] for q in qubits)

cirq/contrib/routing/initialization.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import itertools
 from typing import cast, Dict, Hashable, TYPE_CHECKING
 
@@ -32,7 +34,7 @@ def get_center(graph: nx.Graph) -> Hashable:
 def get_initial_mapping(
     logical_graph: nx.Graph,
     device_graph: nx.Graph,
-    random_state: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None,
+    random_state: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
 ) -> Dict[ops.Qid, ops.Qid]:
     """Gets an initial mapping of logical to physical qubits for routing.