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

cirq/transformers/qubit_management_transformers.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, Optional, Set, Tuple, TYPE_CHECKING
 
 from cirq import circuits, ops
@@ -21,8 +23,8 @@ if TYPE_CHECKING:
 
 
 def _get_qubit_mapping_first_and_last_moment(
-    circuit: 'cirq.AbstractCircuit',
-) -> Dict['cirq.Qid', Tuple[int, int]]:
+    circuit: cirq.AbstractCircuit,
+) -> Dict[cirq.Qid, Tuple[int, int]]:
     """Computes `(first_moment_idx, last_moment_idx)` tuple for each qubit in the input circuit.
 
     Args:
@@ -41,13 +43,13 @@ def _get_qubit_mapping_first_and_last_moment(
     return ret
 
 
-def _is_temp(q: 'cirq.Qid') -> bool:
+def _is_temp(q: cirq.Qid) -> bool:
     return isinstance(q, (ops.CleanQubit, ops.BorrowableQubit))
 
 
 def map_clean_and_borrowable_qubits(
-    circuit: 'cirq.AbstractCircuit', *, qm: Optional['cirq.QubitManager'] = None
-) -> 'cirq.Circuit':
+    circuit: cirq.AbstractCircuit, *, qm: Optional[cirq.QubitManager] = None
+) -> cirq.Circuit:
     """Uses `qm: QubitManager` to map all `CleanQubit`/`BorrowableQubit`s to system qubits.
 
     `CleanQubit` and `BorrowableQubit` are internal qubit types that are used as placeholder qubits
@@ -97,11 +99,11 @@ def map_clean_and_borrowable_qubits(
     trivial_map = {q: q for q in all_qubits}
     # `allocated_map` maintains the mapping of all temporary qubits seen so far, mapping each of
     # them to either a newly allocated managed ancilla or an existing borrowed system qubit.
-    allocated_map: Dict['cirq.Qid', 'cirq.Qid'] = {}
-    to_free: Set['cirq.Qid'] = set()
+    allocated_map: Dict[cirq.Qid, cirq.Qid] = {}
+    to_free: Set[cirq.Qid] = set()
     last_op_idx = -1
 
-    def map_func(op: 'cirq.Operation', idx: int) -> 'cirq.OP_TREE':
+    def map_func(op: cirq.Operation, idx: int) -> cirq.OP_TREE:
         nonlocal last_op_idx, to_free
         assert isinstance(qm, ops.QubitManager)
 

cirq/transformers/randomized_measurements.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 from collections.abc import Sequence
 from typing import Any
 
@@ -39,12 +41,12 @@ class RandomizedMeasurements:
 
     def __call__(
         self,
-        circuit: "cirq.AbstractCircuit",
+        circuit: cirq.AbstractCircuit,
         unitary_ensemble: str = "pauli",
         rng: np.random.Generator | None = None,
         *,
         context: transformer_api.TransformerContext | None = None,
-    ) -> "cirq.Circuit":
+    ) -> cirq.Circuit:
         """Apply the transformer to the given circuit. Given an input circuit returns
         a new circuit with the pre-measurement unitaries and measurements gates added.
         to the qubits in the subsystem provided.If no subsystem is specified in the
@@ -80,7 +82,7 @@ class RandomizedMeasurements:
 
     def random_single_qubit_unitary_moment(
         self, unitary_ensemble: str, qubits: Sequence[Any], rng: np.random.Generator
-    ) -> "cirq.Moment":
+    ) -> cirq.Moment:
         """Outputs the cirq moment associated with the pre-measurement rotations.
 
         Args:
@@ -115,7 +117,7 @@ class RandomizedMeasurements:
         return cirq.Moment.from_ops(*op_list)
 
 
-def _pauli_basis_rotation(rng: np.random.Generator) -> "cirq.Gate":
+def _pauli_basis_rotation(rng: np.random.Generator) -> cirq.Gate:
     """Randomly generate a Pauli basis rotation.
 
     Args:
@@ -127,7 +129,7 @@ def _pauli_basis_rotation(rng: np.random.Generator) -> "cirq.Gate":
     basis_idx = rng.choice(np.arange(3))
 
     if basis_idx == 0:
-        gate: "cirq.Gate" = cirq.Ry(rads=-np.pi / 2)
+        gate: cirq.Gate = cirq.Ry(rads=-np.pi / 2)
     elif basis_idx == 1:
         gate = cirq.Rx(rads=np.pi / 2)
     else:
@@ -135,7 +137,7 @@ def _pauli_basis_rotation(rng: np.random.Generator) -> "cirq.Gate":
     return gate
 
 
-def _single_qubit_clifford(rng: np.random.Generator) -> "cirq.Gate":
+def _single_qubit_clifford(rng: np.random.Generator) -> cirq.Gate:
     """Randomly generate a single-qubit Clifford rotation.
 
     Args:
@@ -153,7 +155,7 @@ def _single_qubit_clifford(rng: np.random.Generator) -> "cirq.Gate":
     )
 
 
-def _single_qubit_cue(rng: np.random.Generator) -> "cirq.Gate":
+def _single_qubit_cue(rng: np.random.Generator) -> cirq.Gate:
     """Randomly generate a CUE gate.
 
     Args:

cirq/transformers/routing/initial_mapper.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 Dict, TYPE_CHECKING
 
@@ -37,7 +39,7 @@ class AbstractInitialMapper(metaclass=abc.ABCMeta):
     """
 
     @abc.abstractmethod
-    def initial_mapping(self, circuit: 'cirq.AbstractCircuit') -> Dict['cirq.Qid', 'cirq.Qid']:
+    def initial_mapping(self, circuit: cirq.AbstractCircuit) -> Dict[cirq.Qid, cirq.Qid]:
         """Maps the logical qubits of a circuit onto physical qubits on a device.
 
         Args:
@@ -52,10 +54,10 @@ class AbstractInitialMapper(metaclass=abc.ABCMeta):
 class HardCodedInitialMapper(AbstractInitialMapper):
     """Initial Mapper class takes a hard-coded mapping and returns it."""
 
-    def __init__(self, _map: Dict['cirq.Qid', 'cirq.Qid']) -> None:
+    def __init__(self, _map: Dict[cirq.Qid, cirq.Qid]) -> None:
         self._map = _map
 
-    def initial_mapping(self, circuit: 'cirq.AbstractCircuit') -> Dict['cirq.Qid', 'cirq.Qid']:
+    def initial_mapping(self, circuit: cirq.AbstractCircuit) -> Dict[cirq.Qid, cirq.Qid]:
         """Returns the hard-coded initial mapping.
 
         Args:

cirq/transformers/routing/line_initial_mapper.py

@@ -30,6 +30,8 @@ If some logical qubits are unampped after this first procedure then there are tw
     the nearest available neighbor to the center of the device.
 """
 
+from __future__ import annotations
+
 from collections import deque
 from typing import Deque, Dict, List, Set, Tuple, TYPE_CHECKING
 
@@ -82,8 +84,8 @@ class LineInitialMapper(initial_mapper.AbstractInitialMapper):
         self.center = nx.center(self.device_graph)[0]
 
     def _make_circuit_graph(
-        self, circuit: 'cirq.AbstractCircuit'
-    ) -> Tuple[List[Deque['cirq.Qid']], Dict['cirq.Qid', 'cirq.Qid']]:
+        self, circuit: cirq.AbstractCircuit
+    ) -> Tuple[List[Deque[cirq.Qid]], Dict[cirq.Qid, cirq.Qid]]:
         """Creates a (potentially incomplete) qubit connectivity graph of the circuit.
 
         Iterates over moments in the circuit from left to right and adds edges between logical
@@ -99,11 +101,11 @@ class LineInitialMapper(initial_mapper.AbstractInitialMapper):
             The (potentially incomplete) qubit connectivity graph of the circuit, which is
                 guaranteed to be a forest of line graphs.
         """
-        circuit_graph: List[Deque['cirq.Qid']] = [deque([q]) for q in sorted(circuit.all_qubits())]
-        component_id: Dict['cirq.Qid', int] = {q[0]: i for i, q in enumerate(circuit_graph)}
-        partners: Dict['cirq.Qid', 'cirq.Qid'] = {}
+        circuit_graph: List[Deque[cirq.Qid]] = [deque([q]) for q in sorted(circuit.all_qubits())]
+        component_id: Dict[cirq.Qid, int] = {q[0]: i for i, q in enumerate(circuit_graph)}
+        partners: Dict[cirq.Qid, cirq.Qid] = {}
 
-        def degree_lt_two(q: 'cirq.Qid'):
+        def degree_lt_two(q: cirq.Qid):
             return any(circuit_graph[component_id[q]][i] == q for i in [-1, 0])
 
         for op in circuit.all_operations():
@@ -141,7 +143,7 @@ class LineInitialMapper(initial_mapper.AbstractInitialMapper):
         )
         return graph, partners
 
-    def initial_mapping(self, circuit: 'cirq.AbstractCircuit') -> Dict['cirq.Qid', 'cirq.Qid']:
+    def initial_mapping(self, circuit: cirq.AbstractCircuit) -> Dict[cirq.Qid, cirq.Qid]:
         """Maps disjoint lines of logical qubits onto lines of physical qubits.
 
         Args:
@@ -151,13 +153,13 @@ class LineInitialMapper(initial_mapper.AbstractInitialMapper):
             a dictionary that maps logical qubits in the circuit (keys) to physical qubits on the
             device (values).
         """
-        mapped_physicals: Set['cirq.Qid'] = set()
-        qubit_map: Dict['cirq.Qid', 'cirq.Qid'] = {}
+        mapped_physicals: Set[cirq.Qid] = set()
+        qubit_map: Dict[cirq.Qid, cirq.Qid] = {}
         circuit_graph, partners = self._make_circuit_graph(circuit)
 
         def next_physical(
-            current_physical: 'cirq.Qid', partner: 'cirq.Qid', isolated: bool = False
-        ) -> 'cirq.Qid':
+            current_physical: cirq.Qid, partner: cirq.Qid, isolated: bool = False
+        ) -> cirq.Qid:
             # Handle the first physical qubit getting mapped.
             if current_physical not in mapped_physicals:
                 return current_physical
@@ -189,8 +191,8 @@ class LineInitialMapper(initial_mapper.AbstractInitialMapper):
         return qubit_map
 
     def _closest_unmapped_qubit(
-        self, source: 'cirq.Qid', mapped_physicals: Set['cirq.Qid']
-    ) -> 'cirq.Qid':
+        self, source: cirq.Qid, mapped_physicals: Set[cirq.Qid]
+    ) -> cirq.Qid:
         """Finds the closest available neighbor to a physical qubit 'source' on the device.
 
         Args:

cirq/transformers/routing/mapping_manager.py

@@ -14,6 +14,8 @@
 
 """Manages the mapping from logical to physical qubits during a routing procedure."""
 
+from __future__ import annotations
+
 from typing import Dict, List, Sequence, TYPE_CHECKING
 
 import networkx as nx
@@ -35,9 +37,7 @@ class MappingManager:
     logical qubits are mapped to, via `self.logical_qid_to_int` map).
     """
 
-    def __init__(
-        self, device_graph: nx.Graph, initial_mapping: Dict['cirq.Qid', 'cirq.Qid']
-    ) -> None:
+    def __init__(self, device_graph: nx.Graph, initial_mapping: Dict[cirq.Qid, cirq.Qid]) -> None:
         """Initializes MappingManager.
 
         Args:
@@ -84,12 +84,12 @@ class MappingManager:
         )
 
     @property
-    def physical_qid_to_int(self) -> Dict['cirq.Qid', int]:
+    def physical_qid_to_int(self) -> Dict[cirq.Qid, int]:
         """Mapping of physical qubits, that were part of the initial mapping, to unique integers."""
         return self._physical_qid_to_int
 
     @property
-    def int_to_physical_qid(self) -> List['cirq.Qid']:
+    def int_to_physical_qid(self) -> List[cirq.Qid]:
         """Inverse mapping of unique integers to corresponding physical qubits.
 
         `self.physical_qid_to_int[self.int_to_physical_qid[i]] == i` for each i.
@@ -97,12 +97,12 @@ class MappingManager:
         return self._int_to_physical_qid
 
     @property
-    def logical_qid_to_int(self) -> Dict['cirq.Qid', int]:
+    def logical_qid_to_int(self) -> Dict[cirq.Qid, int]:
         """Mapping of logical qubits, that were part of the initial mapping, to unique integers."""
         return self._logical_qid_to_int
 
     @property
-    def int_to_logical_qid(self) -> List['cirq.Qid']:
+    def int_to_logical_qid(self) -> List[cirq.Qid]:
         """Inverse mapping of unique integers to corresponding physical qubits.
 
         `self.logical_qid_to_int[self.int_to_logical_qid[i]] == i` for each i.
@@ -178,7 +178,7 @@ class MappingManager:
         self._logical_to_physical[[lq1, lq2]] = self._logical_to_physical[[lq2, lq1]]
         self._physical_to_logical[[pq1, pq2]] = self._physical_to_logical[[pq2, pq1]]
 
-    def mapped_op(self, op: 'cirq.Operation') -> 'cirq.Operation':
+    def mapped_op(self, op: cirq.Operation) -> cirq.Operation:
         """Transforms the given logical operation to act on corresponding physical qubits.
 
         Args:
@@ -189,7 +189,7 @@ class MappingManager:
         """
         logical_ints = [self._logical_qid_to_int[q] for q in op.qubits]
         physical_ints = self.logical_to_physical[logical_ints]
-        qubit_map: Dict['cirq.Qid', 'cirq.Qid'] = {
+        qubit_map: Dict[cirq.Qid, cirq.Qid] = {
             q: self._int_to_physical_qid[physical_ints[i]] for i, q in enumerate(op.qubits)
         }
         return op.transform_qubits(qubit_map)

cirq/transformers/routing/route_circuit_cqc.py

@@ -14,6 +14,8 @@
 
 """Heuristic qubit routing algorithm based on arxiv:1902.08091."""
 
+from __future__ import annotations
+
 import itertools
 from typing import Any, Dict, List, Optional, Sequence, Set, Tuple, TYPE_CHECKING
 
@@ -108,13 +110,13 @@ class RouteCQC:
 
     def __call__(
         self,
-        circuit: 'cirq.AbstractCircuit',
+        circuit: cirq.AbstractCircuit,
         *,
         lookahead_radius: int = 8,
         tag_inserted_swaps: bool = False,
-        initial_mapper: Optional['cirq.AbstractInitialMapper'] = None,
-        context: Optional['cirq.TransformerContext'] = None,
-    ) -> 'cirq.AbstractCircuit':
+        initial_mapper: Optional[cirq.AbstractInitialMapper] = None,
+        context: Optional[cirq.TransformerContext] = None,
+    ) -> cirq.AbstractCircuit:
         """Transforms the given circuit to make it executable on the device.
 
         This method calls self.route_circuit and returns the routed circuit. See docstring of
@@ -150,13 +152,13 @@ class RouteCQC:
 
     def route_circuit(
         self,
-        circuit: 'cirq.AbstractCircuit',
+        circuit: cirq.AbstractCircuit,
         *,
         lookahead_radius: int = 8,
         tag_inserted_swaps: bool = False,
-        initial_mapper: Optional['cirq.AbstractInitialMapper'] = None,
-        context: Optional['cirq.TransformerContext'] = None,
-    ) -> Tuple['cirq.AbstractCircuit', Dict['cirq.Qid', 'cirq.Qid'], Dict['cirq.Qid', 'cirq.Qid']]:
+        initial_mapper: Optional[cirq.AbstractInitialMapper] = None,
+        context: Optional[cirq.TransformerContext] = None,
+    ) -> Tuple[cirq.AbstractCircuit, Dict[cirq.Qid, cirq.Qid], Dict[cirq.Qid, cirq.Qid]]:
         """Transforms the given circuit to make it executable on the device.
 
         This transformer assumes that all multi-qubit operations have been decomposed into 2-qubit
@@ -241,8 +243,8 @@ class RouteCQC:
 
     @classmethod
     def _get_one_and_two_qubit_ops_as_timesteps(
-        cls, circuit: 'cirq.AbstractCircuit'
-    ) -> Tuple[List[List['cirq.Operation']], List[List['cirq.Operation']]]:
+        cls, circuit: cirq.AbstractCircuit
+    ) -> Tuple[List[List[cirq.Operation]], List[List[cirq.Operation]]]:
         """Gets the single and two qubit operations of the circuit factored into timesteps.
 
         The i'th entry in the nested two-qubit and single-qubit ops correspond to the two-qubit
@@ -286,11 +288,11 @@ class RouteCQC:
     def _route(
         cls,
         mm: mapping_manager.MappingManager,
-        two_qubit_ops: List[List['cirq.Operation']],
-        single_qubit_ops: List[List['cirq.Operation']],
+        two_qubit_ops: List[List[cirq.Operation]],
+        single_qubit_ops: List[List[cirq.Operation]],
         lookahead_radius: int,
         tag_inserted_swaps: bool = False,
-    ) -> List[List['cirq.Operation']]:
+    ) -> List[List[cirq.Operation]]:
         """Main routing procedure that inserts necessary swaps on the given timesteps.
 
         The i'th element of the returned list corresponds to the routed operatiosn in the i'th
@@ -316,10 +318,10 @@ class RouteCQC:
             ]
             for timestep_ops in two_qubit_ops
         ]
-        routed_ops: List[List['cirq.Operation']] = []
+        routed_ops: List[List[cirq.Operation]] = []
 
         def process_executable_two_qubit_ops(timestep: int) -> int:
-            unexecutable_ops: List['cirq.Operation'] = []
+            unexecutable_ops: List[cirq.Operation] = []
             unexecutable_ops_ints: List[QidIntPair] = []
             for op, op_ints in zip(two_qubit_ops[timestep], two_qubit_ops_ints[timestep]):
                 if mm.is_adjacent(*op_ints):

cirq/transformers/routing/visualize_routed_circuit.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, Optional, Tuple, TYPE_CHECKING
 
 from cirq import circuits, ops
@@ -23,20 +25,19 @@ if TYPE_CHECKING:
 class _SwapPrintGate(ops.Gate):
     """A gate that displays the string representation of each qubits on the circuit."""
 
-    def __init__(self, qubits: Tuple[Tuple['cirq.Qid', 'cirq.Qid'], ...]) -> None:
+    def __init__(self, qubits: Tuple[Tuple[cirq.Qid, cirq.Qid], ...]) -> None:
         self.qubits = qubits
 
     def num_qubits(self):
         return len(self.qubits)
 
-    def _circuit_diagram_info_(self, args: 'cirq.CircuitDiagramInfoArgs') -> Tuple[str, ...]:
+    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> Tuple[str, ...]:
         return tuple(f'{str(q[1])}' for q in self.qubits)
 
 
 def routed_circuit_with_mapping(
-    routed_circuit: 'cirq.AbstractCircuit',
-    initial_map: Optional[Dict['cirq.Qid', 'cirq.Qid']] = None,
-) -> 'cirq.AbstractCircuit':
+    routed_circuit: cirq.AbstractCircuit, initial_map: Optional[Dict[cirq.Qid, cirq.Qid]] = None
+) -> cirq.AbstractCircuit:
     """Returns the same circuits with information about the permutation of qubits after each swap.
 
     Args:
@@ -54,7 +55,7 @@ def routed_circuit_with_mapping(
         initial_map = qdict.copy()
     inverse_map = {v: k for k, v in initial_map.items()}
 
-    def swap_print_moment() -> 'cirq.Operation':
+    def swap_print_moment() -> cirq.Operation:
         return _SwapPrintGate(
             tuple(zip(qdict.values(), [inverse_map[x] for x in qdict.values()]))
         ).on(*all_qubits)

cirq/transformers/stratify.py

@@ -14,6 +14,8 @@
 
 """Transformer pass to repack circuits avoiding simultaneous operations with different classes."""
 
+from __future__ import annotations
+
 import itertools
 from typing import Callable, Dict, Iterable, List, Optional, Sequence, Type, TYPE_CHECKING, Union
 
@@ -37,11 +39,11 @@ Category = Union[
 
 @transformer_api.transformer(add_deep_support=True)
 def stratified_circuit(
-    circuit: 'cirq.AbstractCircuit',
+    circuit: cirq.AbstractCircuit,
     *,
-    context: Optional['cirq.TransformerContext'] = None,
+    context: Optional[cirq.TransformerContext] = None,
     categories: Iterable[Category] = (),
-) -> 'cirq.Circuit':
+) -> cirq.Circuit:
     """Repacks avoiding simultaneous operations with different classes.
 
     This transforms the given circuit to ensure that no operations of different categories are
@@ -96,9 +98,9 @@ def stratified_circuit(
 def _stratify_circuit(
     circuit: circuits.AbstractCircuit,
     *,
-    context: 'cirq.TransformerContext',
+    context: cirq.TransformerContext,
     classifiers: Sequence[Classifier],
-) -> 'cirq.Circuit':
+) -> cirq.Circuit:
     """Performs the stratification by iterating through the operations in the
     circuit and using the given classifiers to align them.
 
@@ -115,12 +117,12 @@ def _stratify_circuit(
         The stratified circuit.
     """
     num_classes = len(classifiers) + 1  # include one "extra" category for ignored operations
-    new_moments: List[List['cirq.Operation']] = []
+    new_moments: List[List[cirq.Operation]] = []
 
     # Keep track of the latest time index for each qubit, measurement key, and control key.
-    qubit_time_index: Dict['cirq.Qid', int] = {}
-    measurement_time_index: Dict['cirq.MeasurementKey', int] = {}
-    control_time_index: Dict['cirq.MeasurementKey', int] = {}
+    qubit_time_index: Dict[cirq.Qid, int] = {}
+    measurement_time_index: Dict[cirq.MeasurementKey, int] = {}
+    control_time_index: Dict[cirq.MeasurementKey, int] = {}
 
     # The minimum time index for operations with a tag in context.tags_to_ignore.
     last_ignored_ops_time_index = 0
@@ -221,12 +223,12 @@ def _category_to_classifier(category) -> Classifier:
         )
 
 
-def _mock_classifier(op: 'cirq.Operation') -> bool:
+def _mock_classifier(op: cirq.Operation) -> bool:
     """Mock classifier, used to "complete" a collection of classifiers and make it exhaustive."""
     return False  # pragma: no cover
 
 
-def _get_op_class(op: 'cirq.Operation', classifiers: Sequence[Classifier]) -> int:
+def _get_op_class(op: cirq.Operation, classifiers: Sequence[Classifier]) -> int:
     """Get the "class" of an operator, by index."""
     for class_index, classifier in enumerate(classifiers):
         if classifier is _mock_classifier:

cirq/transformers/synchronize_terminal_measurements.py

@@ -14,6 +14,8 @@
 
 """Transformer pass to move terminal measurements to the end of circuit."""
 
+from __future__ import annotations
+
 from typing import List, Optional, Set, Tuple, TYPE_CHECKING
 
 from cirq import circuits, protocols
@@ -23,9 +25,7 @@ if TYPE_CHECKING:
     import cirq
 
 
-def find_terminal_measurements(
-    circuit: 'cirq.AbstractCircuit',
-) -> List[Tuple[int, 'cirq.Operation']]:
+def find_terminal_measurements(circuit: cirq.AbstractCircuit) -> List[Tuple[int, cirq.Operation]]:
     """Finds all terminal measurements in the given circuit.
 
     A measurement is terminal if there are no other operations acting on the measured qubits
@@ -39,9 +39,9 @@ def find_terminal_measurements(
         (moment_index, measurement_operation).
     """
 
-    open_qubits: Set['cirq.Qid'] = set(circuit.all_qubits())
-    seen_control_keys: Set['cirq.MeasurementKey'] = set()
-    terminal_measurements: Set[Tuple[int, 'cirq.Operation']] = set()
+    open_qubits: Set[cirq.Qid] = set(circuit.all_qubits())
+    seen_control_keys: Set[cirq.MeasurementKey] = set()
+    terminal_measurements: Set[Tuple[int, cirq.Operation]] = set()
     for i in range(len(circuit) - 1, -1, -1):
         moment = circuit[i]
         for q in open_qubits:
@@ -62,11 +62,11 @@ def find_terminal_measurements(
 
 @transformer_api.transformer(add_deep_support=True)
 def synchronize_terminal_measurements(
-    circuit: 'cirq.AbstractCircuit',
+    circuit: cirq.AbstractCircuit,
     *,
-    context: Optional['cirq.TransformerContext'] = None,
+    context: Optional[cirq.TransformerContext] = None,
     after_other_operations: bool = True,
-) -> 'cirq.Circuit':
+) -> cirq.Circuit:
     """Move measurements to the end of the circuit.
 
     Move all measurements in a circuit to the final moment, if it can accommodate them (without