cirq-core 1.4.0.dev20240529225110__py3-none-any.whl → 1.5.0__py3-none-any.whl

cirq/contrib/acquaintance/__init__.py

@@ -13,55 +13,70 @@
 # limitations under the License.
 
 """Tools for creating and using acquaintance strategies."""
+from cirq.contrib.acquaintance.bipartite import (
+    BipartiteGraphType as BipartiteGraphType,
+    BipartiteSwapNetworkGate as BipartiteSwapNetworkGate,
+)
 
-from cirq.contrib.acquaintance.bipartite import BipartiteGraphType, BipartiteSwapNetworkGate
-
-from cirq.contrib.acquaintance.devices import get_acquaintance_size, UnconstrainedAcquaintanceDevice
+from cirq.contrib.acquaintance.devices import (
+    get_acquaintance_size as get_acquaintance_size,
+    UnconstrainedAcquaintanceDevice as UnconstrainedAcquaintanceDevice,
+)
 
 from cirq.contrib.acquaintance.executor import (
-    AcquaintanceOperation,
-    GreedyExecutionStrategy,
-    StrategyExecutorTransformer,
+    AcquaintanceOperation as AcquaintanceOperation,
+    GreedyExecutionStrategy as GreedyExecutionStrategy,
+    StrategyExecutorTransformer as StrategyExecutorTransformer,
 )
 
-from cirq.contrib.acquaintance.gates import acquaint, AcquaintanceOpportunityGate, SwapNetworkGate
+from cirq.contrib.acquaintance.gates import (
+    acquaint as acquaint,
+    AcquaintanceOpportunityGate as AcquaintanceOpportunityGate,
+    SwapNetworkGate as SwapNetworkGate,
+)
 
-from cirq.contrib.acquaintance.inspection_utils import get_logical_acquaintance_opportunities
+from cirq.contrib.acquaintance.inspection_utils import (
+    get_logical_acquaintance_opportunities as get_logical_acquaintance_opportunities,
+)
 
 from cirq.contrib.acquaintance.mutation_utils import (
-    expose_acquaintance_gates,
-    rectify_acquaintance_strategy,
-    replace_acquaintance_with_swap_network,
+    expose_acquaintance_gates as expose_acquaintance_gates,
+    rectify_acquaintance_strategy as rectify_acquaintance_strategy,
+    replace_acquaintance_with_swap_network as replace_acquaintance_with_swap_network,
 )
 
-from cirq.contrib.acquaintance.optimizers import remove_redundant_acquaintance_opportunities
+from cirq.contrib.acquaintance.optimizers import (
+    remove_redundant_acquaintance_opportunities as remove_redundant_acquaintance_opportunities,
+)
 
 from cirq.contrib.acquaintance.permutation import (
-    LinearPermutationGate,
-    PermutationGate,
-    SwapPermutationGate,
-    update_mapping,
-    get_logical_operations,
-    display_mapping,
-    return_to_initial_mapping,
-    uses_consistent_swap_gate,
-    EXPAND_PERMUTATION_GATES,
-    DECOMPOSE_PERMUTATION_GATES,
+    LinearPermutationGate as LinearPermutationGate,
+    PermutationGate as PermutationGate,
+    SwapPermutationGate as SwapPermutationGate,
+    update_mapping as update_mapping,
+    get_logical_operations as get_logical_operations,
+    display_mapping as display_mapping,
+    return_to_initial_mapping as return_to_initial_mapping,
+    uses_consistent_swap_gate as uses_consistent_swap_gate,
+    EXPAND_PERMUTATION_GATES as EXPAND_PERMUTATION_GATES,
+    DECOMPOSE_PERMUTATION_GATES as DECOMPOSE_PERMUTATION_GATES,
 )
 
-from cirq.contrib.acquaintance.shift import CircularShiftGate
+from cirq.contrib.acquaintance.shift import CircularShiftGate as CircularShiftGate
 
-from cirq.contrib.acquaintance.shift_swap_network import ShiftSwapNetworkGate
+from cirq.contrib.acquaintance.shift_swap_network import (
+    ShiftSwapNetworkGate as ShiftSwapNetworkGate,
+)
 
 from cirq.contrib.acquaintance.strategies import (
-    complete_acquaintance_strategy,
-    cubic_acquaintance_strategy,
-    quartic_paired_acquaintance_strategy,
+    complete_acquaintance_strategy as complete_acquaintance_strategy,
+    cubic_acquaintance_strategy as cubic_acquaintance_strategy,
+    quartic_paired_acquaintance_strategy as quartic_paired_acquaintance_strategy,
 )
 
 from cirq.contrib.acquaintance.topological_sort import (
-    is_topologically_sorted,
-    random_topological_sort,
+    is_topologically_sorted as is_topologically_sorted,
+    random_topological_sort as random_topological_sort,
 )
 
 from cirq.contrib.acquaintance import testing

cirq/contrib/acquaintance/bipartite.py

@@ -12,12 +12,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import enum
 import itertools
-from typing import Dict, Sequence, Tuple, Union, TYPE_CHECKING
+from typing import Dict, Iterator, Sequence, Tuple, TYPE_CHECKING, Union
 
 from cirq import ops
-
 from cirq.contrib.acquaintance.gates import acquaint
 from cirq.contrib.acquaintance.permutation import PermutationGate, SwapPermutationGate
 
@@ -63,7 +64,7 @@ class BipartiteSwapNetworkGate(PermutationGate):
         self,
         subgraph: Union[str, BipartiteGraphType],
         part_size: int,
-        swap_gate: 'cirq.Gate' = ops.SWAP,
+        swap_gate: cirq.Gate = ops.SWAP,
     ) -> None:
         super().__init__(2 * part_size, swap_gate)
         self.part_size = part_size
@@ -72,7 +73,7 @@ class BipartiteSwapNetworkGate(PermutationGate):
         )
         self.swap_gate = swap_gate
 
-    def decompose_complete(self, qubits: Sequence['cirq.Qid']) -> 'cirq.OP_TREE':
+    def decompose_complete(self, qubits: Sequence[cirq.Qid]) -> Iterator[cirq.OP_TREE]:
         swap_gate = SwapPermutationGate(self.swap_gate)
         if self.part_size == 1:
             yield acquaint(*qubits)
@@ -87,7 +88,7 @@ class BipartiteSwapNetworkGate(PermutationGate):
                 yield acquaint(*qubits[x : x + 2])
                 yield swap_gate(*qubits[x : x + 2])
 
-    def decompose_matching(self, qubits: Sequence['cirq.Qid']) -> 'cirq.OP_TREE':
+    def decompose_matching(self, qubits: Sequence[cirq.Qid]) -> Iterator[cirq.OP_TREE]:
         swap_gate = SwapPermutationGate(self.swap_gate)
         for k in range(-self.part_size + 1, self.part_size):
             for x in range(abs(k), 2 * self.part_size - abs(k), 2):
@@ -96,7 +97,7 @@ class BipartiteSwapNetworkGate(PermutationGate):
                 else:
                     yield acquaint(*qubits[x : x + 2])
 
-    def _decompose_(self, qubits: Sequence['cirq.Qid']) -> 'cirq.OP_TREE':
+    def _decompose_(self, qubits: Sequence[cirq.Qid]) -> cirq.OP_TREE:
         if len(qubits) != 2 * self.part_size:
             raise ValueError('len(qubits) != 2 * self.part_size')
         if self.subgraph == BipartiteGraphType.COMPLETE:
@@ -123,7 +124,7 @@ class BipartiteSwapNetworkGate(PermutationGate):
             return dict(enumerate(range(2 * self.part_size)))
         raise NotImplementedError(str(self.subgraph) + 'not implemented')
 
-    def _circuit_diagram_info_(self, args: 'cirq.CircuitDiagramInfoArgs') -> Tuple[str, ...]:
+    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> Tuple[str, ...]:
         qubit_count = 2 * self.part_size
         if args.known_qubit_count not in (None, qubit_count):
             raise ValueError('args.known_qubit_count not in (None, 2 * self.part_size)')

cirq/contrib/acquaintance/bipartite_test.py

@@ -19,7 +19,6 @@ import pytest
 import cirq
 import cirq.contrib.acquaintance as cca
 
-
 circuit_diagrams = {
     (
         'undecomposed',
@@ -340,3 +339,14 @@ def test_decomposition_permutation_consistency(part_size, subgraph):
     cca.update_mapping(mapping, gate._decompose_(qubits))
     permutation = gate.permutation()
     assert {qubits[i]: j for i, j in permutation.items()} == mapping
+
+
+def test_bad_number_of_qubits():
+    gate = cca.BipartiteSwapNetworkGate(cca.BipartiteGraphType.COMPLETE, 6)
+    qubits = cirq.LineQubit.range(6)
+    mapping = {q: i for i, q in enumerate(qubits)}
+    with pytest.raises(ValueError, match='len'):
+        cca.update_mapping(mapping, gate._decompose_(qubits))
+    gate.part_size = 5
+    with pytest.raises(ValueError, match='qubit_count'):
+        gate.permutation()

cirq/contrib/acquaintance/devices.py

@@ -12,15 +12,16 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Union, TYPE_CHECKING
+from __future__ import annotations
 
 import abc
+from typing import TYPE_CHECKING, Union
 
 from cirq import circuits, devices, ops
-from cirq.contrib.acquaintance.gates import AcquaintanceOpportunityGate, SwapNetworkGate
 from cirq.contrib.acquaintance.bipartite import BipartiteSwapNetworkGate
-from cirq.contrib.acquaintance.shift_swap_network import ShiftSwapNetworkGate
+from cirq.contrib.acquaintance.gates import AcquaintanceOpportunityGate, SwapNetworkGate
 from cirq.contrib.acquaintance.permutation import PermutationGate
+from cirq.contrib.acquaintance.shift_swap_network import ShiftSwapNetworkGate
 
 if TYPE_CHECKING:
     import cirq
@@ -31,7 +32,7 @@ class AcquaintanceDevice(devices.Device, metaclass=abc.ABCMeta):
 
     gate_types = (AcquaintanceOpportunityGate, PermutationGate)
 
-    def validate_operation(self, operation: 'cirq.Operation') -> None:
+    def validate_operation(self, operation: cirq.Operation) -> None:
         if not (
             isinstance(operation, ops.GateOperation) and isinstance(operation.gate, self.gate_types)
         ):

cirq/contrib/acquaintance/devices_test.py

@@ -15,7 +15,6 @@
 import pytest
 
 import cirq
-
 import cirq.contrib.acquaintance as cca
 
 
@@ -28,3 +27,8 @@ def test_acquaintance_device():
     swap_network = cca.SwapNetworkGate((1, 2, 1))
     cca.UnconstrainedAcquaintanceDevice.validate_operation(cca.acquaint(*qubits[:2]))
     cca.UnconstrainedAcquaintanceDevice.validate_operation(swap_network(*qubits))
+
+
+def test_not_operation():
+    with pytest.raises(TypeError):
+        _ = cca.get_acquaintance_size(cirq.LineQubit(1))

cirq/contrib/acquaintance/executor.py

@@ -12,22 +12,22 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import DefaultDict, Dict, Sequence, TYPE_CHECKING, Optional
+from __future__ import annotations
 
 import abc
 from collections import defaultdict
+from typing import DefaultDict, Dict, Iterator, Optional, Sequence, TYPE_CHECKING
 
 from cirq import circuits, devices, ops, protocols, transformers
-
 from cirq.contrib.acquaintance.gates import AcquaintanceOpportunityGate
+from cirq.contrib.acquaintance.mutation_utils import expose_acquaintance_gates
 from cirq.contrib.acquaintance.permutation import (
-    PermutationGate,
+    LogicalGates,
     LogicalIndex,
     LogicalIndexSequence,
-    LogicalGates,
     LogicalMapping,
+    PermutationGate,
 )
-from cirq.contrib.acquaintance.mutation_utils import expose_acquaintance_gates
 
 if TYPE_CHECKING:
     import cirq
@@ -44,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.
         """
@@ -56,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):
@@ -75,6 +75,7 @@ class ExecutionStrategy(metaclass=abc.ABCMeta):
         strategy = StrategyExecutorTransformer(self)
         final_circuit = strategy(input_circuit, **kwargs)
         input_circuit._moments = final_circuit._moments
+        input_circuit._placement_cache = final_circuit._placement_cache
         return strategy.mapping
 
 
@@ -98,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.
 
@@ -127,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)
@@ -151,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)
 
@@ -177,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.
 
@@ -203,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']
-    ) -> '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/executor_test.py

@@ -14,14 +14,14 @@
 
 from itertools import combinations
 from string import ascii_lowercase
-from typing import Sequence, Dict, Tuple
+from typing import Dict, Sequence, Tuple
 
 import numpy as np
 import pytest
 
 import cirq
-import cirq.testing as ct
 import cirq.contrib.acquaintance as cca
+import cirq.testing as ct
 
 
 class ExampleGate(cirq.Gate):
@@ -48,6 +48,7 @@ def test_executor_explicit():
     }
     initial_mapping = {q: i for i, q in enumerate(sorted(qubits))}
     execution_strategy = cca.GreedyExecutionStrategy(gates, initial_mapping)
+    assert execution_strategy.device == cirq.UNCONSTRAINED_DEVICE
 
     with pytest.raises(ValueError):
         executor = cca.StrategyExecutorTransformer(None)

cirq/contrib/acquaintance/gates.py

@@ -12,33 +12,42 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import functools
 import itertools
 import math
 import operator
-from typing import Dict, Iterable, List, NamedTuple, Optional, Sequence, Tuple, TYPE_CHECKING
+from typing import (
+    Dict,
+    Iterable,
+    Iterator,
+    List,
+    NamedTuple,
+    Optional,
+    Sequence,
+    Tuple,
+    TYPE_CHECKING,
+)
 
 from cirq import ops, protocols, value
-
-from cirq.contrib.acquaintance.shift import CircularShiftGate
 from cirq.contrib.acquaintance.permutation import (
+    LinearPermutationGate,
     PermutationGate,
     SwapPermutationGate,
-    LinearPermutationGate,
 )
+from cirq.contrib.acquaintance.shift import CircularShiftGate
 
 if TYPE_CHECKING:
     import cirq
 
 
 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))
 
@@ -62,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
@@ -71,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)
 
 
@@ -87,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],
@@ -144,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
@@ -268,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:
@@ -276,7 +285,7 @@ class SwapNetworkGate(PermutationGate):
         self.part_lens = tuple(part_lens)
         self.acquaintance_size = acquaintance_size
 
-    def _decompose_(self, qubits: Sequence['cirq.Qid']) -> '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 = []
@@ -306,10 +315,12 @@ class SwapNetworkGate(PermutationGate):
                 parts_qubits = list(left_part + right_part)
                 parts[i] = parts_qubits[: len(right_part)]
                 parts[i + 1] = parts_qubits[len(right_part) :]
-            layers.prior_interstitial.sort(key=op_sort_key)
+            if op_sort_key is not None:
+                layers.prior_interstitial.sort(key=op_sort_key)
             for l in ('prior_interstitial', 'pre', 'intra', 'post'):
                 yield getattr(layers, l)
-        layers.posterior_interstitial.sort(key=op_sort_key)
+        if op_sort_key is not None:
+            layers.posterior_interstitial.sort(key=op_sort_key)
         yield layers.posterior_interstitial
 
         assert list(
@@ -322,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})'
@@ -335,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/gates_test.py

@@ -21,8 +21,8 @@ import numpy
 import pytest
 
 import cirq
-import cirq.testing as ct
 import cirq.contrib.acquaintance as cca
+import cirq.testing as ct
 
 
 def test_acquaintance_gate_repr():

cirq/contrib/acquaintance/inspection_utils.py

@@ -12,17 +12,18 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import FrozenSet, Sequence, Set, TYPE_CHECKING
+from __future__ import annotations
 
-from cirq import devices
+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
-from cirq.contrib import circuitdag
 
 if TYPE_CHECKING:
     import cirq
+    from cirq.contrib.acquaintance.permutation import LogicalIndex, LogicalMapping
 
 
 class LogicalAnnotator(ExecutionStrategy):
@@ -41,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']
-    ) -> '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)
@@ -64,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/inspection_utils_test.py

@@ -12,12 +12,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from itertools import product, combinations
+from itertools import combinations, product
 
 import pytest
 
 import cirq
 import cirq.contrib.acquaintance as cca
+import cirq.contrib.acquaintance.inspection_utils as inspection_utils
 
 
 @pytest.mark.parametrize('n_qubits, acquaintance_size', product(range(2, 6), range(2, 5)))
@@ -27,3 +28,7 @@ def test_get_logical_acquaintance_opportunities(n_qubits, acquaintance_size):
     initial_mapping = {q: i for i, q in enumerate(qubits)}
     opps = cca.get_logical_acquaintance_opportunities(acquaintance_strategy, initial_mapping)
     assert opps == set(frozenset(s) for s in combinations(range(n_qubits), acquaintance_size))
+
+
+def test_device():
+    assert inspection_utils.LogicalAnnotator({}).device == cirq.UNCONSTRAINED_DEVICE