cirq-core 1.5.0.dev20250409222543__py3-none-any.whl → 1.6.0__py3-none-any.whl

cirq/contrib/acquaintance/optimizers.py

@@ -14,7 +14,7 @@
 
 from __future__ import annotations
 
-from typing import cast, FrozenSet, List, Sequence, Set, TYPE_CHECKING
+from typing import cast, Sequence, TYPE_CHECKING
 
 from cirq import circuits
 from cirq.contrib.acquaintance.executor import AcquaintanceOperation
@@ -36,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] = []
-    acquaintance_opps: Set[FrozenSet[int]] = set()
+    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/optimizers_test.py

@@ -11,12 +11,15 @@
 # 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
+
 import cirq
 import cirq.contrib.acquaintance as cca
 import cirq.testing as ct
 
 
-def test_remove_redundant_acquaintance_opportunities():
+def test_remove_redundant_acquaintance_opportunities() -> None:
     a, b, c, d, e = cirq.LineQubit.range(5)
     swap = cca.SwapPermutationGate()
 

cirq/contrib/acquaintance/permutation.py

@@ -16,19 +16,7 @@ from __future__ import annotations
 
 import abc
 from types import NotImplementedType
-from typing import (
-    Any,
-    cast,
-    Dict,
-    Iterable,
-    Iterator,
-    Optional,
-    Sequence,
-    Tuple,
-    TYPE_CHECKING,
-    TypeVar,
-    Union,
-)
+from typing import Any, cast, Iterable, Iterator, Sequence, TYPE_CHECKING, TypeVar
 
 from cirq import circuits, ops, protocols, transformers, value
 
@@ -37,10 +25,10 @@ if TYPE_CHECKING:
 
 
 LogicalIndex = TypeVar('LogicalIndex', int, ops.Qid)
-LogicalIndexSequence = Union[Sequence[int], Sequence['cirq.Qid']]
-LogicalGates = Dict[Tuple[LogicalIndex, ...], ops.Gate]
+LogicalIndexSequence = Sequence[int] | Sequence['cirq.Qid']
+LogicalGates = dict[tuple[LogicalIndex, ...], ops.Gate]
 LogicalMappingKey = TypeVar('LogicalMappingKey', bound=ops.Qid)
-LogicalMapping = Dict[LogicalMappingKey, LogicalIndex]
+LogicalMapping = dict[LogicalMappingKey, LogicalIndex]
 
 
 class PermutationGate(ops.Gate, metaclass=abc.ABCMeta):
@@ -61,12 +49,12 @@ class PermutationGate(ops.Gate, metaclass=abc.ABCMeta):
         return self._num_qubits
 
     @abc.abstractmethod
-    def permutation(self) -> Dict[int, int]:
+    def permutation(self) -> dict[int, int]:
         """permutation = {i: s[i]} indicates that the i-th element is mapped to
         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.
 
@@ -86,7 +74,7 @@ class PermutationGate(ops.Gate, metaclass=abc.ABCMeta):
                 mapping[new_key] = old_element
 
     @staticmethod
-    def validate_permutation(permutation: Dict[int, int], n_elements: Optional[int] = None) -> None:
+    def validate_permutation(permutation: dict[int, int], n_elements: int | None = None) -> None:
         if not permutation:
             return
         if set(permutation.values()) != set(permutation):
@@ -99,7 +87,7 @@ class PermutationGate(ops.Gate, metaclass=abc.ABCMeta):
 
     def _circuit_diagram_info_(
         self, args: cirq.CircuitDiagramInfoArgs
-    ) -> Union[str, Iterable[str], cirq.CircuitDiagramInfo]:
+    ) -> str | Iterable[str] | cirq.CircuitDiagramInfo:
         if args.known_qubit_count is None:
             return NotImplemented
         permutation = self.permutation()
@@ -150,7 +138,7 @@ class SwapPermutationGate(PermutationGate):
     def __init__(self, swap_gate: cirq.Gate = ops.SWAP):
         super().__init__(2, swap_gate)
 
-    def permutation(self) -> Dict[int, int]:
+    def permutation(self) -> dict[int, int]:
         return {0: 1, 1: 0}
 
     def _decompose_(self, qubits: Sequence[cirq.Qid]) -> Iterator[cirq.OP_TREE]:
@@ -166,7 +154,7 @@ class SwapPermutationGate(PermutationGate):
     def _value_equality_values_(self) -> Any:
         return (self.swap_gate,)
 
-    def _commutes_(self, other: Any, *, atol: float = 1e-8) -> Union[bool, NotImplementedType]:
+    def _commutes_(self, other: Any, *, atol: float = 1e-8) -> bool | NotImplementedType:
         if (
             isinstance(other, ops.Gate)
             and isinstance(other, ops.InterchangeableQubitsGate)
@@ -176,7 +164,7 @@ class SwapPermutationGate(PermutationGate):
         return NotImplemented
 
 
-def _canonicalize_permutation(permutation: Dict[int, int]) -> Dict[int, int]:
+def _canonicalize_permutation(permutation: dict[int, int]) -> dict[int, int]:
     return {i: j for i, j in permutation.items() if i != j}
 
 
@@ -186,7 +174,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.
 
@@ -199,7 +187,7 @@ class LinearPermutationGate(PermutationGate):
         PermutationGate.validate_permutation(permutation, num_qubits)
         self._permutation = permutation
 
-    def permutation(self) -> Dict[int, int]:
+    def permutation(self) -> dict[int, int]:
         return self._permutation
 
     def _decompose_(self, qubits: Sequence[cirq.Qid]) -> Iterator[cirq.OP_TREE]:
@@ -238,7 +226,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,7 +241,7 @@ def update_mapping(mapping: Dict[ops.Qid, LogicalIndex], operations: cirq.OP_TRE
 
 
 def get_logical_operations(
-    operations: cirq.OP_TREE, initial_mapping: Dict[ops.Qid, ops.Qid]
+    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.

cirq/contrib/acquaintance/permutation_test.py

@@ -12,7 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import random
+from typing import Iterator
 
 import pytest
 
@@ -21,7 +24,7 @@ import cirq.contrib.acquaintance as cca
 import cirq.testing as ct
 
 
-def test_swap_permutation_gate():
+def test_swap_permutation_gate() -> None:
     no_decomp = lambda op: (isinstance(op, cirq.GateOperation) and op.gate == cirq.SWAP)
     a, b = cirq.NamedQubit('a'), cirq.NamedQubit('b')
     gate = cca.SwapPermutationGate()
@@ -40,7 +43,7 @@ def test_swap_permutation_gate():
         cirq.commutes(gate, cirq.CCZ)
 
 
-def test_validate_permutation_errors():
+def test_validate_permutation_errors() -> None:
     validate_permutation = cca.PermutationGate.validate_permutation
     validate_permutation({})
 
@@ -57,7 +60,7 @@ def test_validate_permutation_errors():
     assert cirq.circuit_diagram_info(gate, default=None) is None
 
 
-def test_diagram():
+def test_diagram() -> None:
     gate = cca.SwapPermutationGate()
     a, b = cirq.NamedQubit('a'), cirq.NamedQubit('b')
     circuit = cirq.Circuit([gate(a, b)])
@@ -70,17 +73,19 @@ b: ───1↦0───
     assert actual_text_diagram == expected_text_diagram
 
 
-def test_update_mapping():
+def test_update_mapping() -> None:
     gate = cca.SwapPermutationGate()
     a, b, c = (cirq.NamedQubit(s) for s in 'abc')
+    mapping: dict[cirq.Qid, int]
     mapping = {s: i for i, s in enumerate((a, b, c))}
     ops = [gate(a, b), gate(b, c)]
     cca.update_mapping(mapping, ops)
     assert mapping == {a: 1, b: 2, c: 0}
 
 
-def test_get_logical_operations():
+def test_get_logical_operations() -> None:
     a, b, c, d = qubits = cirq.LineQubit.range(4)
+    mapping: dict[cirq.Qid, cirq.Qid]
     mapping = dict(zip(qubits, qubits))
     operations = [
         cirq.ZZ(a, b),
@@ -104,7 +109,7 @@ def test_get_logical_operations():
         for n_elements in (random.randint(5, 20) for _ in range(20))
     ),
 )
-def test_linear_permutation_gate(n_elements, n_permuted):
+def test_linear_permutation_gate(n_elements, n_permuted) -> None:
     qubits = cirq.LineQubit.range(n_elements)
     elements = tuple(range(n_elements))
     elements_to_permute = random.sample(elements, n_permuted)
@@ -114,16 +119,18 @@ def test_linear_permutation_gate(n_elements, n_permuted):
     gate = cca.LinearPermutationGate(n_elements, permutation)
     ct.assert_equivalent_repr(gate)
     assert gate.permutation() == permutation
+    mapping: dict[cirq.Qid, int]
     mapping = dict(zip(qubits, elements))
     for swap in cirq.flatten_op_tree(cirq.decompose_once_with_qubits(gate, qubits)):
         assert isinstance(swap, cirq.GateOperation)
+        assert isinstance(swap.gate, cca.PermutationGate)
         swap.gate.update_mapping(mapping, swap.qubits)
     for i in range(n_elements):
         p = permutation.get(elements[i], i)
         assert mapping.get(qubits[p], elements[i]) == i
 
 
-def random_equal_permutations(n_perms, n_items, prob):
+def random_equal_permutations(n_perms, n_items, prob) -> list[dict[int, int]]:
     indices_to_permute = [i for i in range(n_items) if random.random() <= prob]
     permuted_indices = random.sample(indices_to_permute, len(indices_to_permute))
     base_permutation = dict(zip(indices_to_permute, permuted_indices))
@@ -136,7 +143,9 @@ def random_equal_permutations(n_perms, n_items, prob):
     return permutations
 
 
-def random_permutation_equality_groups(n_groups, n_perms_per_group, n_items, prob):
+def random_permutation_equality_groups(
+    n_groups, n_perms_per_group, n_items, prob
+) -> Iterator[list[dict[int, int]]]:
     fingerprints = set()
     for _ in range(n_groups):
         perms = random_equal_permutations(n_perms_per_group, n_items, prob)
@@ -148,7 +157,7 @@ def random_permutation_equality_groups(n_groups, n_perms_per_group, n_items, pro
 
 
 @pytest.mark.parametrize('permutation_sets', [random_permutation_equality_groups(5, 3, 10, 0.5)])
-def test_linear_permutation_gate_equality(permutation_sets):
+def test_linear_permutation_gate_equality(permutation_sets) -> None:
     swap_gates = [cirq.SWAP, cirq.CNOT]
     equals_tester = ct.EqualsTester()
     for swap_gate in swap_gates:
@@ -161,7 +170,7 @@ def test_linear_permutation_gate_equality(permutation_sets):
             )
 
 
-def test_linear_permutation_gate_pow_not_implemented():
+def test_linear_permutation_gate_pow_not_implemented() -> None:
     permutation_gate = cca.LinearPermutationGate(3, {0: 1, 1: 2, 2: 0})
 
     assert permutation_gate.__pow__(0) is NotImplemented
@@ -181,7 +190,7 @@ def test_linear_permutation_gate_pow_not_implemented():
         (4, {0: 3, 1: 2, 2: 1, 3: 0}),
     ],
 )
-def test_linear_permutation_gate_pow_identity(num_qubits, permutation):
+def test_linear_permutation_gate_pow_identity(num_qubits, permutation) -> None:
     permutation_gate = cca.LinearPermutationGate(num_qubits, permutation)
 
     assert permutation_gate**1 == permutation_gate
@@ -197,7 +206,7 @@ def test_linear_permutation_gate_pow_identity(num_qubits, permutation):
         (4, {0: 3, 1: 2, 2: 1, 3: 0}, {0: 3, 1: 2, 2: 1, 3: 0}),
     ],
 )
-def test_linear_permutation_gate_pow_inverse(num_qubits, permutation, inverse):
+def test_linear_permutation_gate_pow_inverse(num_qubits, permutation, inverse) -> None:
     permutation_gate = cca.LinearPermutationGate(num_qubits, permutation)
     inverse_gate = cca.LinearPermutationGate(num_qubits, inverse)
 
@@ -205,7 +214,7 @@ def test_linear_permutation_gate_pow_inverse(num_qubits, permutation, inverse):
     assert cirq.inverse(permutation_gate) == inverse_gate
 
 
-def test_display_mapping():
+def test_display_mapping() -> None:
     indices = [4, 2, 0, 1, 3]
     qubits = cirq.LineQubit.range(len(indices))
     circuit = cca.complete_acquaintance_strategy(qubits, 2)
@@ -236,7 +245,7 @@ def test_display_mapping():
         for _ in range(4)
     ],
 )
-def test_return_to_initial_mapping(circuit):
+def test_return_to_initial_mapping(circuit) -> None:
     qubits = sorted(circuit.all_qubits())
     cca.return_to_initial_mapping(circuit)
     initial_mapping = {q: i for i, q in enumerate(qubits)}
@@ -245,7 +254,7 @@ def test_return_to_initial_mapping(circuit):
     assert mapping == initial_mapping
 
 
-def test_uses_consistent_swap_gate():
+def test_uses_consistent_swap_gate() -> None:
     a, b = cirq.LineQubit.range(2)
     circuit = cirq.Circuit([cca.SwapPermutationGate()(a, b), cca.SwapPermutationGate()(a, b)])
     assert cca.uses_consistent_swap_gate(circuit, cirq.SWAP)
@@ -262,7 +271,7 @@ def test_uses_consistent_swap_gate():
     assert not cca.uses_consistent_swap_gate(circuit, cirq.CZ)
 
 
-def test_swap_gate_eq():
+def test_swap_gate_eq() -> None:
     assert cca.SwapPermutationGate() == cca.SwapPermutationGate(cirq.SWAP)
     assert cca.SwapPermutationGate() != cca.SwapPermutationGate(cirq.CZ)
     assert cca.SwapPermutationGate(cirq.CZ) == cca.SwapPermutationGate(cirq.CZ)
@@ -276,5 +285,5 @@ def test_swap_gate_eq():
         cca.SwapPermutationGate(cirq.CZ),
     ],
 )
-def test_swap_gate_repr(gate):
+def test_swap_gate_repr(gate) -> None:
     cirq.testing.assert_equivalent_repr(gate)

cirq/contrib/acquaintance/shift.py

@@ -15,7 +15,7 @@
 from __future__ import annotations
 
 import itertools
-from typing import Any, Dict, Iterator, Sequence, Tuple, TYPE_CHECKING
+from typing import Any, Iterator, Sequence, TYPE_CHECKING
 
 from cirq import ops, value
 from cirq.contrib.acquaintance.permutation import PermutationGate, SwapPermutationGate
@@ -36,7 +36,7 @@ class CircularShiftGate(PermutationGate):
             shift: The number of positions to circularly left shift the qubits.
             swap_gate: The gate to use when decomposing.
         """
-        super(CircularShiftGate, self).__init__(num_qubits, swap_gate)
+        super().__init__(num_qubits, swap_gate)
         self.shift = shift
 
     def __repr__(self) -> str:
@@ -60,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 ('\\', '/')
@@ -72,7 +72,7 @@ class CircularShiftGate(PermutationGate):
         )
         return wire_symbols
 
-    def permutation(self) -> Dict[int, int]:
+    def permutation(self) -> dict[int, int]:
         shift = self.shift % self.num_qubits()
         permuted_indices = itertools.chain(range(shift, self.num_qubits()), range(shift))
         return {s: i for i, s in enumerate(permuted_indices)}

cirq/contrib/acquaintance/shift_swap_network.py

@@ -16,7 +16,7 @@ from __future__ import annotations
 
 import functools
 import itertools
-from typing import Dict, Iterable, Iterator, Optional, Sequence, Tuple, TYPE_CHECKING
+from typing import Iterable, Iterator, Sequence, TYPE_CHECKING
 
 from cirq import ops
 from cirq.contrib.acquaintance.gates import acquaint
@@ -93,7 +93,7 @@ class ShiftSwapNetworkGate(PermutationGate):
                 parts[k] = parts_qubits[: len(right_part)]
                 parts[k + 1] = parts_qubits[len(right_part) :]
 
-    def qubit_count(self, side: Optional[str] = None) -> int:
+    def qubit_count(self, side: str | None = None) -> int:
         if side is None:
             return sum(self.qubit_count(side) for side in self.part_lens)
         return sum(self.part_lens[side])
@@ -101,7 +101,7 @@ class ShiftSwapNetworkGate(PermutationGate):
     def num_qubits(self) -> int:
         return self.qubit_count()
 
-    def permutation(self) -> Dict[int, int]:
+    def permutation(self) -> dict[int, int]:
         return dict(
             zip(
                 range(self.num_qubits()),
@@ -112,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/shift_swap_network_test.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
 import random
 
@@ -21,7 +23,7 @@ import cirq
 import cirq.contrib.acquaintance as cca
 
 
-def random_part_lens(max_n_parts, max_part_size):
+def random_part_lens(max_n_parts, max_part_size) -> tuple[int, ...]:
     return tuple(random.randint(1, max_part_size) for _ in range(random.randint(1, max_n_parts)))
 
 
@@ -29,7 +31,7 @@ def random_part_lens(max_n_parts, max_part_size):
     'left_part_lens,right_part_lens',
     [tuple(random_part_lens(7, 2) for _ in ('left', 'right')) for _ in range(5)],
 )
-def test_shift_swap_network_gate_acquaintance_opps(left_part_lens, right_part_lens):
+def test_shift_swap_network_gate_acquaintance_opps(left_part_lens, right_part_lens) -> None:
 
     gate = cca.ShiftSwapNetworkGate(left_part_lens, right_part_lens)
     n_qubits = gate.qubit_count()
@@ -43,6 +45,7 @@ def test_shift_swap_network_gate_acquaintance_opps(left_part_lens, right_part_le
     # expected opps
     i = 0
     sides = ('left', 'right')
+    parts: dict[str, list[set[int]]]
     parts = {side: [] for side in sides}
     for side, part_lens in zip(sides, (left_part_lens, right_part_lens)):
         for part_len in part_lens:
@@ -203,7 +206,7 @@ circuit_diagrams = {
 
 
 @pytest.mark.parametrize('left_part_lens,right_part_lens', set(key[1:] for key in circuit_diagrams))
-def test_shift_swap_network_gate_diagrams(left_part_lens, right_part_lens):
+def test_shift_swap_network_gate_diagrams(left_part_lens, right_part_lens) -> None:
 
     gate = cca.ShiftSwapNetworkGate(left_part_lens, right_part_lens)
     n_qubits = gate.qubit_count()
@@ -218,7 +221,7 @@ def test_shift_swap_network_gate_diagrams(left_part_lens, right_part_lens):
     cirq.testing.assert_has_diagram(circuit, diagram)
 
 
-def test_shift_swap_network_gate_bad_part_lens():
+def test_shift_swap_network_gate_bad_part_lens() -> None:
     with pytest.raises(ValueError):
         cca.ShiftSwapNetworkGate((0, 1, 1), (2, 2))
     with pytest.raises(ValueError):
@@ -233,7 +236,7 @@ def test_shift_swap_network_gate_bad_part_lens():
     'left_part_lens,right_part_lens',
     [tuple(random_part_lens(2, 2) for _ in ('left', 'right')) for _ in range(5)],
 )
-def test_shift_swap_network_gate_repr(left_part_lens, right_part_lens):
+def test_shift_swap_network_gate_repr(left_part_lens, right_part_lens) -> None:
     gate = cca.ShiftSwapNetworkGate(left_part_lens, right_part_lens)
     cirq.testing.assert_equivalent_repr(gate)
 
@@ -245,7 +248,7 @@ def test_shift_swap_network_gate_repr(left_part_lens, right_part_lens):
     'left_part_lens,right_part_lens',
     [tuple(random_part_lens(2, 2) for _ in ('left', 'right')) for _ in range(5)],
 )
-def test_shift_swap_network_gate_permutation(left_part_lens, right_part_lens):
+def test_shift_swap_network_gate_permutation(left_part_lens, right_part_lens) -> None:
     gate = cca.ShiftSwapNetworkGate(left_part_lens, right_part_lens)
     n_qubits = gate.qubit_count()
     cca.testing.assert_permutation_decomposition_equivalence(gate, n_qubits)

cirq/contrib/acquaintance/shift_test.py

@@ -12,11 +12,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import cirq
 import cirq.contrib.acquaintance as cca
 
 
-def test_circular_shift_gate_init():
+def test_circular_shift_gate_init() -> None:
     g = cca.CircularShiftGate(4, 2)
     assert g.num_qubits() == 4
     assert g.shift == 2
@@ -25,7 +27,7 @@ def test_circular_shift_gate_init():
     assert g.swap_gate == cirq.CZ
 
 
-def test_circular_shift_gate_eq():
+def test_circular_shift_gate_eq() -> None:
     equals_tester = cirq.testing.EqualsTester()
     equals_tester.add_equality_group(cca.CircularShiftGate(4, 1), cca.CircularShiftGate(4, 1))
     equals_tester.add_equality_group(cca.CircularShiftGate(4, 1, swap_gate=cirq.CZ))
@@ -34,19 +36,19 @@ def test_circular_shift_gate_eq():
     equals_tester.add_equality_group(cca.CircularShiftGate(3, 2, swap_gate=cirq.CZ))
 
 
-def test_circular_shift_gate_permutation():
+def test_circular_shift_gate_permutation() -> None:
     assert cca.CircularShiftGate(3, 4).permutation() == {0: 2, 1: 0, 2: 1}
     assert cca.CircularShiftGate(4, 0).permutation() == {0: 0, 1: 1, 2: 2, 3: 3}
 
     assert cca.CircularShiftGate(5, 2).permutation() == {0: 3, 1: 4, 2: 0, 3: 1, 4: 2}
 
 
-def test_circular_shift_gate_repr():
+def test_circular_shift_gate_repr() -> None:
     g = cca.CircularShiftGate(3, 2)
     cirq.testing.assert_equivalent_repr(g)
 
 
-def test_circular_shift_gate_decomposition():
+def test_circular_shift_gate_decomposition() -> None:
     qubits = [cirq.NamedQubit(q) for q in 'abcdef']
 
     circular_shift = cca.CircularShiftGate(2, 1, cirq.CZ)(*qubits[:2])
@@ -92,7 +94,7 @@ f: ───────────────×───────
     assert actual_text_diagram == expected_text_diagram
 
 
-def test_circular_shift_gate_wire_symbols():
+def test_circular_shift_gate_wire_symbols() -> None:
     qubits = [cirq.NamedQubit(q) for q in 'xyz']
     circuit = cirq.Circuit(cca.CircularShiftGate(3, 2)(*qubits))
     actual_text_diagram = circuit.to_text_diagram().strip()

cirq/contrib/acquaintance/strategies/cubic.py

@@ -15,7 +15,7 @@
 from __future__ import annotations
 
 import itertools
-from typing import Iterable, Sequence, Tuple, TYPE_CHECKING, TypeVar
+from typing import Iterable, Sequence, TYPE_CHECKING, TypeVar
 
 from cirq import circuits, ops
 from cirq.contrib.acquaintance.gates import acquaint
@@ -27,7 +27,7 @@ if TYPE_CHECKING:
 TItem = TypeVar('TItem')
 
 
-def skip_and_wrap_around(items: Sequence[TItem]) -> Tuple[TItem, ...]:
+def skip_and_wrap_around(items: Sequence[TItem]) -> tuple[TItem, ...]:
     n_items = len(items)
     positions = {
         p: i

cirq/contrib/acquaintance/strategies/cubic_test.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
 
 import pytest
@@ -21,7 +23,7 @@ import cirq.contrib.acquaintance as cca
 import cirq.contrib.acquaintance.strategies.cubic as ccasc
 
 
-def test_skip_and_wrap_around():
+def test_skip_and_wrap_around() -> None:
     assert ccasc.skip_and_wrap_around(range(3)) == (0, 2, 1)
     assert ccasc.skip_and_wrap_around(range(4)) == (0, 3, 1, 2)
     assert ccasc.skip_and_wrap_around('abcde') == tuple('aebdc')
@@ -29,7 +31,7 @@ def test_skip_and_wrap_around():
 
 
 @pytest.mark.parametrize('n_qubits', range(3, 9))
-def test_cubic_acquaintance_strategy(n_qubits):
+def test_cubic_acquaintance_strategy(n_qubits) -> None:
     qubits = tuple(cirq.LineQubit.range(n_qubits))
     strategy = cca.cubic_acquaintance_strategy(qubits)
     initial_mapping = {q: i for i, q in enumerate(qubits)}

cirq/contrib/acquaintance/strategies/quartic_paired.py

@@ -14,7 +14,7 @@
 
 from __future__ import annotations
 
-from typing import cast, Iterable, List, Sequence, Tuple, TYPE_CHECKING
+from typing import cast, Iterable, Sequence, TYPE_CHECKING
 
 from cirq import circuits
 from cirq.contrib.acquaintance.gates import acquaint, SwapNetworkGate
@@ -24,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.
 
@@ -35,7 +35,7 @@ def qubit_pairs_to_qubit_order(qubit_pairs: Sequence[Sequence[cirq.Qid]]) -> Lis
     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],
@@ -49,15 +49,15 @@ def qubit_pairs_to_qubit_order(qubit_pairs: Sequence[Sequence[cirq.Qid]]) -> Lis
 
 
 def quartic_paired_acquaintance_strategy(
-    qubit_pairs: Iterable[Tuple[cirq.Qid, cirq.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', 'cirq.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)