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

cirq/contrib/acquaintance/executor.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 collections import defaultdict
 from typing import DefaultDict, Dict, Iterator, Optional, Sequence, TYPE_CHECKING
@@ -42,7 +44,7 @@ class ExecutionStrategy(metaclass=abc.ABCMeta):
 
     @property
     @abc.abstractmethod
-    def device(self) -> 'cirq.Device':
+    def device(self) -> cirq.Device:
         """The device for which the executed acquaintance strategy should be
         valid.
         """
@@ -54,8 +56,8 @@ class ExecutionStrategy(metaclass=abc.ABCMeta):
 
     @abc.abstractmethod
     def get_operations(
-        self, indices: Sequence[LogicalIndex], qubits: Sequence['cirq.Qid']
-    ) -> 'cirq.OP_TREE':
+        self, indices: Sequence[LogicalIndex], qubits: Sequence[cirq.Qid]
+    ) -> cirq.OP_TREE:
         """Gets the logical operations to apply to qubits."""
 
     def __call__(self, *args, **kwargs):
@@ -97,13 +99,13 @@ class StrategyExecutorTransformer:
         self._mapping = execution_strategy.initial_mapping.copy()
 
     def __call__(
-        self, circuit: circuits.AbstractCircuit, context: Optional['cirq.TransformerContext'] = None
+        self, circuit: circuits.AbstractCircuit, context: Optional[cirq.TransformerContext] = None
     ) -> circuits.Circuit:
         """Executes an acquaintance strategy using cirq.map_operations_and_unroll and
         mutates initial mapping.
 
         Args:
-            circuit: 'cirq.Circuit' input circuit to transform.
+            circuit: `cirq.Circuit` input circuit to transform.
             context: `cirq.TransformerContext` storing common configurable
               options for transformers.
 
@@ -126,7 +128,7 @@ class StrategyExecutorTransformer:
     def mapping(self) -> LogicalMapping:
         return self._mapping
 
-    def _map_func(self, op: 'cirq.Operation', index) -> 'cirq.OP_TREE':
+    def _map_func(self, op: cirq.Operation, index) -> cirq.OP_TREE:
         if isinstance(op.gate, AcquaintanceOpportunityGate):
             logical_indices = tuple(self._mapping[q] for q in op.qubits)
             logical_operations = self.execution_strategy.get_operations(logical_indices, op.qubits)
@@ -150,17 +152,13 @@ class AcquaintanceOperation(ops.GateOperation):
     logical indices on a particular set of physical qubits.
     """
 
-    def __init__(
-        self, qubits: Sequence['cirq.Qid'], logical_indices: Sequence[LogicalIndex]
-    ) -> None:
+    def __init__(self, qubits: Sequence[cirq.Qid], logical_indices: Sequence[LogicalIndex]) -> None:
         if len(logical_indices) != len(qubits):
             raise ValueError('len(logical_indices) != len(qubits)')
         super().__init__(AcquaintanceOpportunityGate(num_qubits=len(qubits)), qubits)
         self.logical_indices: LogicalIndexSequence = logical_indices
 
-    def _circuit_diagram_info_(
-        self, args: 'cirq.CircuitDiagramInfoArgs'
-    ) -> 'cirq.CircuitDiagramInfo':
+    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> cirq.CircuitDiagramInfo:
         wire_symbols = tuple(f'({i})' for i in self.logical_indices)
         return protocols.CircuitDiagramInfo(wire_symbols=wire_symbols)
 
@@ -176,7 +174,7 @@ class GreedyExecutionStrategy(ExecutionStrategy):
         self,
         gates: LogicalGates,
         initial_mapping: LogicalMapping,
-        device: Optional['cirq.Device'] = None,
+        device: Optional[cirq.Device] = None,
     ) -> None:
         """Inits GreedyExecutionStrategy.
 
@@ -202,12 +200,12 @@ class GreedyExecutionStrategy(ExecutionStrategy):
         return self._initial_mapping
 
     @property
-    def device(self) -> 'cirq.Device':
+    def device(self) -> cirq.Device:
         return self._device
 
     def get_operations(
-        self, indices: Sequence[LogicalIndex], qubits: Sequence['cirq.Qid']
-    ) -> Iterator['cirq.OP_TREE']:
+        self, indices: Sequence[LogicalIndex], qubits: Sequence[cirq.Qid]
+    ) -> Iterator[cirq.OP_TREE]:
         index_set = frozenset(indices)
         if index_set in self.index_set_to_gates:
             gates = self.index_set_to_gates.pop(index_set)

cirq/contrib/acquaintance/gates.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
 import itertools
 import math
@@ -41,13 +43,11 @@ if TYPE_CHECKING:
 
 
 def operations_to_part_lens(
-    qubit_order: Sequence['cirq.Qid'], op_tree: 'cirq.OP_TREE'
+    qubit_order: Sequence[cirq.Qid], op_tree: cirq.OP_TREE
 ) -> Tuple[int, ...]:
     qubit_sort_key = functools.partial(operator.indexOf, qubit_order)
     op_parts = [tuple(sorted(op.qubits, key=qubit_sort_key)) for op in ops.flatten_op_tree(op_tree)]
-    singletons: List[Tuple['cirq.Qid', ...]] = [
-        (q,) for q in set(qubit_order).difference(*op_parts)
-    ]
+    singletons: List[Tuple[cirq.Qid, ...]] = [(q,) for q in set(qubit_order).difference(*op_parts)]
     part_sort_key = lambda p: min(qubit_sort_key(q) for q in p)
     parts = tuple(tuple(part) for part in sorted(singletons + op_parts, key=part_sort_key))
 
@@ -71,7 +71,7 @@ class AcquaintanceOpportunityGate(ops.Gate, ops.InterchangeableQubitsGate):
             f'num_qubits={self.num_qubits()!r})'
         )
 
-    def _circuit_diagram_info_(self, args: 'cirq.CircuitDiagramInfoArgs') -> Iterable[str]:
+    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> Iterable[str]:
         wire_symbol = '█' if args.use_unicode_characters else 'Acq'
         wire_symbols = (wire_symbol,) * self.num_qubits()
         return wire_symbols
@@ -80,7 +80,7 @@ class AcquaintanceOpportunityGate(ops.Gate, ops.InterchangeableQubitsGate):
         return self._num_qubits
 
 
-def acquaint(*qubits) -> 'cirq.Operation':
+def acquaint(*qubits) -> cirq.Operation:
     return AcquaintanceOpportunityGate(len(qubits)).on(*qubits)
 
 
@@ -96,14 +96,14 @@ Layers = NamedTuple(
 )
 
 
-def new_layers(**kwargs: List['cirq.Operation']) -> Layers:
+def new_layers(**kwargs: List[cirq.Operation]) -> Layers:
     return Layers._make(kwargs.get(field, []) for field in Layers._fields)
 
 
 def acquaint_insides(
-    swap_gate: 'cirq.Gate',
-    acquaintance_gate: 'cirq.Operation',
-    qubits: Sequence['cirq.Qid'],
+    swap_gate: cirq.Gate,
+    acquaintance_gate: cirq.Operation,
+    qubits: Sequence[cirq.Qid],
     before: bool,
     layers: Layers,
     mapping: Dict[ops.Qid, int],
@@ -153,10 +153,10 @@ def _get_max_reach(size: int, round_up: bool = True) -> int:
 
 
 def acquaint_and_shift(
-    parts: Tuple[List['cirq.Qid'], List['cirq.Qid']],
+    parts: Tuple[List[cirq.Qid], List[cirq.Qid]],
     layers: Layers,
     acquaintance_size: Optional[int],
-    swap_gate: 'cirq.Gate',
+    swap_gate: cirq.Gate,
     mapping: Dict[ops.Qid, int],
 ):
     """Acquaints and shifts a pair of lists of qubits. The first part is
@@ -277,7 +277,7 @@ class SwapNetworkGate(PermutationGate):
         self,
         part_lens: Sequence[int],
         acquaintance_size: Optional[int] = 0,
-        swap_gate: 'cirq.Gate' = ops.SWAP,
+        swap_gate: cirq.Gate = ops.SWAP,
     ) -> None:
         super().__init__(sum(part_lens), swap_gate)
         if len(part_lens) < 2:
@@ -285,7 +285,7 @@ class SwapNetworkGate(PermutationGate):
         self.part_lens = tuple(part_lens)
         self.acquaintance_size = acquaintance_size
 
-    def _decompose_(self, qubits: Sequence['cirq.Qid']) -> Iterator['cirq.OP_TREE']:
+    def _decompose_(self, qubits: Sequence[cirq.Qid]) -> Iterator[cirq.OP_TREE]:
         qubit_to_position = {q: i for i, q in enumerate(qubits)}
         mapping = dict(qubit_to_position)
         parts = []
@@ -333,9 +333,7 @@ class SwapNetworkGate(PermutationGate):
         if final_gate:
             yield final_gate(*qubits)
 
-    def _circuit_diagram_info_(
-        self, args: 'cirq.CircuitDiagramInfoArgs'
-    ) -> 'cirq.CircuitDiagramInfo':
+    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> cirq.CircuitDiagramInfo:
         wire_symbol = '×' if args.use_unicode_characters else 'swap'
         wire_symbols = tuple(
             wire_symbol + f'({part_index},{qubit_index})'
@@ -346,11 +344,11 @@ class SwapNetworkGate(PermutationGate):
 
     @staticmethod
     def from_operations(
-        qubit_order: Sequence['cirq.Qid'],
-        operations: Sequence['cirq.Operation'],
+        qubit_order: Sequence[cirq.Qid],
+        operations: Sequence[cirq.Operation],
         acquaintance_size: Optional[int] = 0,
-        swap_gate: 'cirq.Gate' = ops.SWAP,
-    ) -> 'SwapNetworkGate':
+        swap_gate: cirq.Gate = ops.SWAP,
+    ) -> SwapNetworkGate:
         part_sizes = operations_to_part_lens(qubit_order, operations)
         return SwapNetworkGate(part_sizes, acquaintance_size, swap_gate)
 

cirq/contrib/acquaintance/inspection_utils.py

@@ -12,16 +12,18 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 from typing import FrozenSet, Iterator, Sequence, Set, TYPE_CHECKING
 
 from cirq import devices
 from cirq.contrib import circuitdag
 from cirq.contrib.acquaintance.executor import AcquaintanceOperation, ExecutionStrategy
 from cirq.contrib.acquaintance.mutation_utils import expose_acquaintance_gates
-from cirq.contrib.acquaintance.permutation import LogicalIndex, LogicalMapping
 
 if TYPE_CHECKING:
     import cirq
+    from cirq.contrib.acquaintance.permutation import LogicalIndex, LogicalMapping
 
 
 class LogicalAnnotator(ExecutionStrategy):
@@ -40,16 +42,16 @@ class LogicalAnnotator(ExecutionStrategy):
         return self._initial_mapping
 
     @property
-    def device(self) -> 'cirq.Device':
+    def device(self) -> cirq.Device:
         return devices.UNCONSTRAINED_DEVICE
 
     def get_operations(
-        self, indices: Sequence[LogicalIndex], qubits: Sequence['cirq.Qid']
-    ) -> Iterator['cirq.OP_TREE']:
+        self, indices: Sequence[LogicalIndex], qubits: Sequence[cirq.Qid]
+    ) -> Iterator[cirq.OP_TREE]:
         yield AcquaintanceOperation(qubits, indices)
 
 
-def get_acquaintance_dag(strategy: 'cirq.Circuit', initial_mapping: LogicalMapping):
+def get_acquaintance_dag(strategy: cirq.Circuit, initial_mapping: LogicalMapping):
     strategy = strategy.copy()
     expose_acquaintance_gates(strategy)
     LogicalAnnotator(initial_mapping)(strategy)
@@ -63,7 +65,7 @@ def get_acquaintance_dag(strategy: 'cirq.Circuit', initial_mapping: LogicalMappi
 
 
 def get_logical_acquaintance_opportunities(
-    strategy: 'cirq.Circuit', initial_mapping: LogicalMapping
+    strategy: cirq.Circuit, initial_mapping: LogicalMapping
 ) -> Set[FrozenSet[LogicalIndex]]:
     acquaintance_dag = get_acquaintance_dag(strategy, initial_mapping)
     logical_acquaintance_opportunities = set()

cirq/contrib/acquaintance/mutation_utils.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import collections
 from typing import cast, Dict, List, Optional, Sequence, TYPE_CHECKING, Union
 
@@ -26,7 +28,7 @@ if TYPE_CHECKING:
 STRATEGY_GATE = Union[AcquaintanceOpportunityGate, PermutationGate]
 
 
-def rectify_acquaintance_strategy(circuit: 'cirq.Circuit', acquaint_first: bool = True) -> None:
+def rectify_acquaintance_strategy(circuit: cirq.Circuit, acquaint_first: bool = True) -> None:
     """Splits moments so that they contain either only acquaintance or permutation gates.
 
     Orders resulting moments so that the first one is of the same type as the previous one.
@@ -55,10 +57,10 @@ def rectify_acquaintance_strategy(circuit: 'cirq.Circuit', acquaint_first: bool
 
 
 def replace_acquaintance_with_swap_network(
-    circuit: 'cirq.Circuit',
-    qubit_order: Sequence['cirq.Qid'],
+    circuit: cirq.Circuit,
+    qubit_order: Sequence[cirq.Qid],
     acquaintance_size: Optional[int] = 0,
-    swap_gate: 'cirq.Gate' = ops.SWAP,
+    swap_gate: cirq.Gate = ops.SWAP,
 ) -> bool:
     """Replace every rectified moment with acquaintance gates with a generalized swap network.
 
@@ -104,10 +106,10 @@ class ExposeAcquaintanceGates:
             not get_acquaintance_size(op) or isinstance(op.gate, AcquaintanceOpportunityGate)
         )
 
-    def optimize_circuit(self, circuit: 'cirq.Circuit') -> None:
+    def optimize_circuit(self, circuit: cirq.Circuit) -> None:
         circuit._moments = [*transformers.expand_composite(circuit, no_decomp=self.no_decomp)]
 
-    def __call__(self, circuit: 'cirq.Circuit') -> None:
+    def __call__(self, circuit: cirq.Circuit) -> None:
         self.optimize_circuit(circuit)
 
 

cirq/contrib/acquaintance/optimizers.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 cast, FrozenSet, List, Sequence, Set, TYPE_CHECKING
 
 from cirq import circuits
@@ -24,7 +26,7 @@ if TYPE_CHECKING:
     import cirq
 
 
-def remove_redundant_acquaintance_opportunities(strategy: 'cirq.Circuit') -> int:
+def remove_redundant_acquaintance_opportunities(strategy: cirq.Circuit) -> int:
     """Removes redundant acquaintance opportunities."""
 
     qubits = sorted(strategy.all_qubits())
@@ -34,11 +36,11 @@ def remove_redundant_acquaintance_opportunities(strategy: 'cirq.Circuit') -> int
     annotated_strategy = strategy.copy()
     LogicalAnnotator(mapping)(annotated_strategy)
 
-    new_moments: List['cirq.Moment'] = []
+    new_moments: List[cirq.Moment] = []
     acquaintance_opps: Set[FrozenSet[int]] = set()
     n_removed = 0
     for moment in annotated_strategy:
-        new_moment: List['cirq.Operation'] = []
+        new_moment: List[cirq.Operation] = []
         for op in moment:
             if isinstance(op, AcquaintanceOperation):
                 opp = frozenset(cast(Sequence[int], op.logical_indices))

cirq/contrib/acquaintance/permutation.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 (
@@ -51,7 +53,7 @@ class PermutationGate(ops.Gate, metaclass=abc.ABCMeta):
             qubits (e.g. SWAP or fermionic swap).
     """
 
-    def __init__(self, num_qubits: int, swap_gate: 'cirq.Gate' = ops.SWAP) -> None:
+    def __init__(self, num_qubits: int, swap_gate: cirq.Gate = ops.SWAP) -> None:
         self._num_qubits = num_qubits
         self.swap_gate = swap_gate
 
@@ -64,7 +66,7 @@ class PermutationGate(ops.Gate, metaclass=abc.ABCMeta):
         the s[i]-th element."""
 
     def update_mapping(
-        self, mapping: Dict[ops.Qid, LogicalIndex], keys: Sequence['cirq.Qid']
+        self, mapping: Dict[ops.Qid, LogicalIndex], keys: Sequence[cirq.Qid]
     ) -> None:
         """Updates a mapping (in place) from qubits to logical indices.
 
@@ -96,8 +98,8 @@ class PermutationGate(ops.Gate, metaclass=abc.ABCMeta):
                 raise IndexError('key is out of bounds.')
 
     def _circuit_diagram_info_(
-        self, args: 'cirq.CircuitDiagramInfoArgs'
-    ) -> Union[str, Iterable[str], 'cirq.CircuitDiagramInfo']:
+        self, args: cirq.CircuitDiagramInfoArgs
+    ) -> Union[str, Iterable[str], cirq.CircuitDiagramInfo]:
         if args.known_qubit_count is None:
             return NotImplemented
         permutation = self.permutation()
@@ -118,14 +120,12 @@ class MappingDisplayGate(ops.Gate):
     def num_qubits(self) -> int:
         return self._num_qubits
 
-    def _circuit_diagram_info_(
-        self, args: 'cirq.CircuitDiagramInfoArgs'
-    ) -> 'cirq.CircuitDiagramInfo':
+    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> cirq.CircuitDiagramInfo:
         wire_symbols = tuple('' if i is None else str(i) for i in self.indices)
         return protocols.CircuitDiagramInfo(wire_symbols, connected=False)
 
 
-def display_mapping(circuit: 'cirq.Circuit', initial_mapping: LogicalMapping) -> None:
+def display_mapping(circuit: cirq.Circuit, initial_mapping: LogicalMapping) -> None:
     """Inserts display gates between moments to indicate the mapping throughout
     the circuit."""
     qubits = sorted(circuit.all_qubits())
@@ -147,13 +147,13 @@ def display_mapping(circuit: 'cirq.Circuit', initial_mapping: LogicalMapping) ->
 class SwapPermutationGate(PermutationGate):
     """Generic swap gate."""
 
-    def __init__(self, swap_gate: 'cirq.Gate' = ops.SWAP):
+    def __init__(self, swap_gate: cirq.Gate = ops.SWAP):
         super().__init__(2, swap_gate)
 
     def permutation(self) -> Dict[int, int]:
         return {0: 1, 1: 0}
 
-    def _decompose_(self, qubits: Sequence['cirq.Qid']) -> Iterator['cirq.OP_TREE']:
+    def _decompose_(self, qubits: Sequence[cirq.Qid]) -> Iterator[cirq.OP_TREE]:
         yield self.swap_gate(*qubits)
 
     def __repr__(self) -> str:
@@ -186,7 +186,7 @@ class LinearPermutationGate(PermutationGate):
     sorting network."""
 
     def __init__(
-        self, num_qubits: int, permutation: Dict[int, int], swap_gate: 'cirq.Gate' = ops.SWAP
+        self, num_qubits: int, permutation: Dict[int, int], swap_gate: cirq.Gate = ops.SWAP
     ) -> None:
         """Initializes a linear permutation gate.
 
@@ -202,7 +202,7 @@ class LinearPermutationGate(PermutationGate):
     def permutation(self) -> Dict[int, int]:
         return self._permutation
 
-    def _decompose_(self, qubits: Sequence['cirq.Qid']) -> Iterator['cirq.OP_TREE']:
+    def _decompose_(self, qubits: Sequence[cirq.Qid]) -> Iterator[cirq.OP_TREE]:
         swap_gate = SwapPermutationGate(self.swap_gate)
         n_qubits = len(qubits)
         mapping = {i: self._permutation.get(i, i) for i in range(n_qubits)}
@@ -238,7 +238,7 @@ class LinearPermutationGate(PermutationGate):
         return NotImplemented
 
 
-def update_mapping(mapping: Dict[ops.Qid, LogicalIndex], operations: 'cirq.OP_TREE') -> None:
+def update_mapping(mapping: Dict[ops.Qid, LogicalIndex], operations: cirq.OP_TREE) -> None:
     """Updates a mapping (in place) from qubits to logical indices according to
     a set of permutation gates. Any gates other than permutation gates are
     ignored.
@@ -253,8 +253,8 @@ def update_mapping(mapping: Dict[ops.Qid, LogicalIndex], operations: 'cirq.OP_TR
 
 
 def get_logical_operations(
-    operations: 'cirq.OP_TREE', initial_mapping: Dict[ops.Qid, ops.Qid]
-) -> Iterable['cirq.Operation']:
+    operations: cirq.OP_TREE, initial_mapping: Dict[ops.Qid, ops.Qid]
+) -> Iterable[cirq.Operation]:
     """Gets the logical operations specified by the physical operations and
     initial mapping.
 
@@ -300,10 +300,10 @@ class DecomposePermutationGates:
                 not all([isinstance(op, ops.GateOperation), isinstance(op.gate, PermutationGate)])
             )
 
-    def optimize_circuit(self, circuit: 'cirq.Circuit') -> None:
+    def optimize_circuit(self, circuit: cirq.Circuit) -> None:
         circuit._moments = [*transformers.expand_composite(circuit, no_decomp=self.no_decomp)]
 
-    def __call__(self, circuit: 'cirq.Circuit') -> None:
+    def __call__(self, circuit: cirq.Circuit) -> None:
         self.optimize_circuit(circuit)
 
 
@@ -311,7 +311,7 @@ EXPAND_PERMUTATION_GATES = DecomposePermutationGates(keep_swap_permutations=True
 DECOMPOSE_PERMUTATION_GATES = DecomposePermutationGates(keep_swap_permutations=False)
 
 
-def return_to_initial_mapping(circuit: 'cirq.Circuit', swap_gate: 'cirq.Gate' = ops.SWAP) -> None:
+def return_to_initial_mapping(circuit: cirq.Circuit, swap_gate: cirq.Gate = ops.SWAP) -> None:
     qubits = sorted(circuit.all_qubits())
     n_qubits = len(qubits)
 
@@ -323,7 +323,7 @@ def return_to_initial_mapping(circuit: 'cirq.Circuit', swap_gate: 'cirq.Gate' =
     circuit.append(returning_permutation_op)
 
 
-def uses_consistent_swap_gate(circuit: 'cirq.Circuit', swap_gate: 'cirq.Gate') -> bool:
+def uses_consistent_swap_gate(circuit: cirq.Circuit, swap_gate: cirq.Gate) -> bool:
     for op in circuit.all_operations():
         if isinstance(op, ops.GateOperation) and isinstance(op.gate, PermutationGate):
             if op.gate.swap_gate != swap_gate:

cirq/contrib/acquaintance/shift.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 Any, Dict, Iterator, Sequence, Tuple, TYPE_CHECKING
 
@@ -26,7 +28,7 @@ if TYPE_CHECKING:
 class CircularShiftGate(PermutationGate):
     """Performs a cyclical permutation of the qubits to the left by a specified amount."""
 
-    def __init__(self, num_qubits: int, shift: int, swap_gate: 'cirq.Gate' = ops.SWAP) -> None:
+    def __init__(self, num_qubits: int, shift: int, swap_gate: cirq.Gate = ops.SWAP) -> None:
         """Construct a circular shift gate.
 
         Args:
@@ -47,7 +49,7 @@ class CircularShiftGate(PermutationGate):
     def _value_equality_values_(self) -> Any:
         return self.shift, self.swap_gate, self.num_qubits()
 
-    def _decompose_(self, qubits: Sequence['cirq.Qid']) -> Iterator['cirq.OP_TREE']:
+    def _decompose_(self, qubits: Sequence[cirq.Qid]) -> Iterator[cirq.OP_TREE]:
         n = len(qubits)
         left_shift = self.shift % n
         right_shift = n - left_shift
@@ -58,7 +60,7 @@ class CircularShiftGate(PermutationGate):
             for k in range(i, j, 2):
                 yield swap_gate(*qubits[k : k + 2])
 
-    def _circuit_diagram_info_(self, args: 'cirq.CircuitDiagramInfoArgs') -> Tuple[str, ...]:
+    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> Tuple[str, ...]:
         if args.known_qubit_count is None:
             return NotImplemented  # pragma: no cover
         direction_symbols = ('╲', '╱') if args.use_unicode_characters else ('\\', '/')

cirq/contrib/acquaintance/shift_swap_network.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
 import itertools
 from typing import Dict, Iterable, Iterator, Optional, Sequence, Tuple, TYPE_CHECKING
@@ -51,7 +53,7 @@ class ShiftSwapNetworkGate(PermutationGate):
         self,
         left_part_lens: Iterable[int],
         right_part_lens: Iterable[int],
-        swap_gate: 'cirq.Gate' = ops.SWAP,
+        swap_gate: cirq.Gate = ops.SWAP,
     ) -> None:
 
         self.part_lens = {'left': tuple(left_part_lens), 'right': tuple(right_part_lens)}
@@ -65,7 +67,7 @@ class ShiftSwapNetworkGate(PermutationGate):
     def acquaintance_size(self) -> int:
         return sum(max(self.part_lens[side]) for side in ('left', 'right'))
 
-    def _decompose_(self, qubits: Sequence['cirq.Qid']) -> Iterator['cirq.OP_TREE']:
+    def _decompose_(self, qubits: Sequence[cirq.Qid]) -> Iterator[cirq.OP_TREE]:
         part_lens = list(itertools.chain(*(self.part_lens[side] for side in ('left', 'right'))))
 
         n_qubits = 0
@@ -110,7 +112,7 @@ class ShiftSwapNetworkGate(PermutationGate):
             )
         )
 
-    def _circuit_diagram_info_(self, args: 'cirq.CircuitDiagramInfoArgs') -> Tuple[str, ...]:
+    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> Tuple[str, ...]:
         qubit_count = self.qubit_count()
         assert args.known_qubit_count in (None, qubit_count)
 

cirq/contrib/acquaintance/strategies/complete.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, ops
@@ -26,8 +28,8 @@ if TYPE_CHECKING:
 
 
 def complete_acquaintance_strategy(
-    qubit_order: Sequence['cirq.Qid'], acquaintance_size: int = 0, swap_gate: 'cirq.Gate' = ops.SWAP
-) -> 'cirq.Circuit':
+    qubit_order: Sequence[cirq.Qid], acquaintance_size: int = 0, swap_gate: cirq.Gate = ops.SWAP
+) -> cirq.Circuit:
     """Returns an acquaintance strategy with can handle the given number of qubits.
 
     Args:

cirq/contrib/acquaintance/strategies/cubic.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 Iterable, Sequence, Tuple, TYPE_CHECKING, TypeVar
 
@@ -35,8 +37,8 @@ def skip_and_wrap_around(items: Sequence[TItem]) -> Tuple[TItem, ...]:
 
 
 def cubic_acquaintance_strategy(
-    qubits: Iterable['cirq.Qid'], swap_gate: 'cirq.Gate' = ops.SWAP
-) -> 'cirq.Circuit':
+    qubits: Iterable[cirq.Qid], swap_gate: cirq.Gate = ops.SWAP
+) -> cirq.Circuit:
     """Acquaints every triple of qubits.
 
     Exploits the fact that in a simple linear swap network every pair of

cirq/contrib/acquaintance/strategies/quartic_paired.py

@@ -12,9 +12,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 from typing import cast, Iterable, List, Sequence, Tuple, TYPE_CHECKING
 
-from cirq import circuits, ops
+from cirq import circuits
 from cirq.contrib.acquaintance.gates import acquaint, SwapNetworkGate
 from cirq.contrib.acquaintance.mutation_utils import expose_acquaintance_gates
 
@@ -22,7 +24,7 @@ if TYPE_CHECKING:
     import cirq
 
 
-def qubit_pairs_to_qubit_order(qubit_pairs: Sequence[Sequence['cirq.Qid']]) -> List['cirq.Qid']:
+def qubit_pairs_to_qubit_order(qubit_pairs: Sequence[Sequence[cirq.Qid]]) -> List[cirq.Qid]:
     """Takes a sequence of qubit pairs and returns a sequence in which every
     pair is at distance two.
 
@@ -33,7 +35,7 @@ def qubit_pairs_to_qubit_order(qubit_pairs: Sequence[Sequence['cirq.Qid']]) -> L
     if set(len(qubit_pair) for qubit_pair in qubit_pairs) != set((2,)):
         raise ValueError('set(len(qubit_pair) for qubit_pair in qubit_pairs) != set((2,))')
     n_pairs = len(qubit_pairs)
-    qubits: List['cirq.Qid'] = []
+    qubits: List[cirq.Qid] = []
     for i in range(0, 2 * (n_pairs // 2), 2):
         qubits += [
             qubit_pairs[i][0],
@@ -47,15 +49,15 @@ def qubit_pairs_to_qubit_order(qubit_pairs: Sequence[Sequence['cirq.Qid']]) -> L
 
 
 def quartic_paired_acquaintance_strategy(
-    qubit_pairs: Iterable[Tuple['cirq.Qid', ops.Qid]],
-) -> Tuple['cirq.Circuit', Sequence['cirq.Qid']]:
+    qubit_pairs: Iterable[Tuple[cirq.Qid, cirq.Qid]],
+) -> Tuple[cirq.Circuit, Sequence[cirq.Qid]]:
     """Acquaintance strategy for pairs of pairs.
 
     Implements UpCCGSD ansatz from arXiv:1810.02327.
     """
 
     qubit_pairs = tuple(
-        cast(Tuple['cirq.Qid', ops.Qid], tuple(qubit_pair)) for qubit_pair in qubit_pairs
+        cast(Tuple['cirq.Qid', 'cirq.Qid'], tuple(qubit_pair)) for qubit_pair in qubit_pairs
     )
     qubits = qubit_pairs_to_qubit_order(qubit_pairs)
     n_qubits = len(qubits)

cirq/contrib/acquaintance/topological_sort.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import operator
 import random
 from typing import Any, Callable, cast, Iterable, TYPE_CHECKING
@@ -25,8 +27,8 @@ if TYPE_CHECKING:
 
 
 def is_topologically_sorted(
-    dag: 'cirq.contrib.CircuitDag',
-    operations: 'cirq.OP_TREE',
+    dag: cirq.contrib.CircuitDag,
+    operations: cirq.OP_TREE,
     equals: Callable[[ops.Operation, ops.Operation], bool] = operator.eq,
 ) -> bool:
     """Whether a given order of operations is consistent with the DAG.