cirq-core 1.6.0.dev20250520054601__py3-none-any.whl → 1.6.0.dev20250520181654__py3-none-any.whl

cirq/circuits/qasm_output.py

@@ -17,7 +17,7 @@
 from __future__ import annotations
 
 import re
-from typing import Callable, Dict, Iterator, Optional, Sequence, Tuple, TYPE_CHECKING, Union
+from typing import Callable, Iterator, Sequence, TYPE_CHECKING
 
 import numpy as np
 
@@ -55,7 +55,7 @@ class QasmUGate(ops.Gate):
     def _has_unitary_(self):
         return True
 
-    def _qasm_(self, qubits: Tuple[cirq.Qid, ...], args: cirq.QasmArgs) -> str:
+    def _qasm_(self, qubits: tuple[cirq.Qid, ...], args: cirq.QasmArgs) -> str:
         args.validate_version('2.0', '3.0')
         return args.format(
             'u3({0:half_turns},{1:half_turns},{2:half_turns}) {3};\n',
@@ -84,7 +84,7 @@ class QasmUGate(ops.Gate):
     def _value_equality_values_(self):
         return self.lmda, self.theta, self.phi
 
-    def _json_dict_(self) -> Dict[str, float]:
+    def _json_dict_(self) -> dict[str, float]:
         return {'theta': self.theta, 'phi': self.phi, 'lmda': self.lmda}
 
     @classmethod
@@ -173,7 +173,7 @@ class QasmOutput:
     def __init__(
         self,
         operations: cirq.OP_TREE,
-        qubits: Tuple[cirq.Qid, ...],
+        qubits: tuple[cirq.Qid, ...],
         header: str = '',
         precision: int = 10,
         version: str = '2.0',
@@ -208,10 +208,10 @@ class QasmOutput:
             meas_key_bitcount={k: v[0] for k, v in self.cregs.items()},
         )
 
-    def _generate_measurement_ids(self) -> Tuple[Dict[str, str], Dict[str, Optional[str]]]:
+    def _generate_measurement_ids(self) -> tuple[dict[str, str], dict[str, str | None]]:
         # Pick an id for the creg that will store each measurement
-        meas_key_id_map: Dict[str, str] = {}
-        meas_comments: Dict[str, Optional[str]] = {}
+        meas_key_id_map: dict[str, str] = {}
+        meas_comments: dict[str, str | None] = {}
         meas_i = 0
         for meas in self.measurements:
             key = protocols.measurement_key_name(meas)
@@ -227,10 +227,10 @@ class QasmOutput:
             meas_key_id_map[key] = meas_id
         return meas_key_id_map, meas_comments
 
-    def _generate_qubit_ids(self) -> Dict[cirq.Qid, str]:
+    def _generate_qubit_ids(self) -> dict[cirq.Qid, str]:
         return {qubit: f'q[{i}]' for i, qubit in enumerate(self.qubits)}
 
-    def _generate_cregs(self, meas_key_id_map: Dict[str, str]) -> Dict[str, tuple[int, str]]:
+    def _generate_cregs(self, meas_key_id_map: dict[str, str]) -> dict[str, tuple[int, str]]:
         """Pick an id for the creg that will store each measurement
 
         This function finds the largest measurement using each key.
@@ -239,7 +239,7 @@ class QasmOutput:
 
         Returns: dictionary with key of measurement id and value of (#qubits, comment).
         """
-        cregs: Dict[str, tuple[int, str]] = {}
+        cregs: dict[str, tuple[int, str]] = {}
         for meas in self.measurements:
             key = protocols.measurement_key_name(meas)
             meas_id = meas_key_id_map[key]
@@ -258,7 +258,7 @@ class QasmOutput:
         """Test if id_str is a valid id in QASM grammar."""
         return self.valid_id_re.match(id_str) is not None
 
-    def save(self, path: Union[str, bytes, int]) -> None:
+    def save(self, path: str | bytes | int) -> None:
         """Write QASM output to a file specified by path."""
         with open(path, 'w') as f:
 

cirq/circuits/text_diagram_drawer.py

@@ -14,20 +14,7 @@
 
 from __future__ import annotations
 
-from typing import (
-    Any,
-    Callable,
-    cast,
-    Dict,
-    Iterable,
-    List,
-    Mapping,
-    NamedTuple,
-    Optional,
-    Sequence,
-    Tuple,
-    TYPE_CHECKING,
-)
+from typing import Any, Callable, cast, Iterable, Mapping, NamedTuple, Sequence, TYPE_CHECKING
 
 import numpy as np
 
@@ -73,25 +60,25 @@ class TextDiagramDrawer:
 
     def __init__(
         self,
-        entries: Optional[Mapping[Tuple[int, int], _DiagramText]] = None,
-        horizontal_lines: Optional[Iterable[_HorizontalLine]] = None,
-        vertical_lines: Optional[Iterable[_VerticalLine]] = None,
-        horizontal_padding: Optional[Mapping[int, int]] = None,
-        vertical_padding: Optional[Mapping[int, int]] = None,
+        entries: Mapping[tuple[int, int], _DiagramText] | None = None,
+        horizontal_lines: Iterable[_HorizontalLine] | None = None,
+        vertical_lines: Iterable[_VerticalLine] | None = None,
+        horizontal_padding: Mapping[int, int] | None = None,
+        vertical_padding: Mapping[int, int] | None = None,
     ) -> None:
-        self.entries: Dict[Tuple[int, int], _DiagramText] = (
+        self.entries: dict[tuple[int, int], _DiagramText] = (
             dict() if entries is None else dict(entries)
         )
-        self.horizontal_lines: List[_HorizontalLine] = (
+        self.horizontal_lines: list[_HorizontalLine] = (
             [] if horizontal_lines is None else list(horizontal_lines)
         )
-        self.vertical_lines: List[_VerticalLine] = (
+        self.vertical_lines: list[_VerticalLine] = (
             [] if vertical_lines is None else list(vertical_lines)
         )
-        self.horizontal_padding: Dict[int, float] = (
+        self.horizontal_padding: dict[int, float] = (
             dict() if horizontal_padding is None else dict(horizontal_padding)
         )
-        self.vertical_padding: Dict[int, float] = (
+        self.vertical_padding: dict[int, float] = (
             dict() if vertical_padding is None else dict(vertical_padding)
         )
 
@@ -108,7 +95,7 @@ class TextDiagramDrawer:
     def __bool__(self):
         return any(self._value_equality_values_())
 
-    def write(self, x: int, y: int, text: str, transposed_text: Optional[str] = None):
+    def write(self, x: int, y: int, text: str, transposed_text: str | None = None):
         """Adds text to the given location.
 
         Args:
@@ -215,7 +202,7 @@ class TextDiagramDrawer:
         """Change the padding after the given row."""
         self.vertical_padding[index] = padding
 
-    def _transform_coordinates(self, func: Callable[[float, float], Tuple[float, float]]) -> None:
+    def _transform_coordinates(self, func: Callable[[float, float], tuple[float, float]]) -> None:
         """Helper method to transformer either row or column coordinates."""
 
         def func_x(x: float) -> float:
@@ -225,7 +212,7 @@ class TextDiagramDrawer:
             return func(0, y)[1]
 
         self.entries = {
-            cast(Tuple[int, int], func(int(x), int(y))): v for (x, y), v in self.entries.items()
+            cast(tuple[int, int], func(int(x), int(y))): v for (x, y), v in self.entries.items()
         }
         self.vertical_lines = [
             _VerticalLine(func_x(x), func_y(y1), func_y(y2), emph, doubled)
@@ -245,7 +232,7 @@ class TextDiagramDrawer:
     def insert_empty_columns(self, x: int, amount: int = 1) -> None:
         """Insert a number of columns after the given column."""
 
-        def transform_columns(column: float, row: float) -> Tuple[float, float]:
+        def transform_columns(column: float, row: float) -> tuple[float, float]:
             return column + (amount if column >= x else 0), row
 
         self._transform_coordinates(transform_columns)
@@ -253,7 +240,7 @@ class TextDiagramDrawer:
     def insert_empty_rows(self, y: int, amount: int = 1) -> None:
         """Insert a number of rows after the given row."""
 
-        def transform_rows(column: float, row: float) -> Tuple[float, float]:
+        def transform_rows(column: float, row: float) -> tuple[float, float]:
             return column, row + (amount if row >= y else 0)
 
         self._transform_coordinates(transform_rows)
@@ -262,7 +249,7 @@ class TextDiagramDrawer:
         self,
         horizontal_spacing: int = 1,
         vertical_spacing: int = 1,
-        crossing_char: Optional[str] = None,
+        crossing_char: str | None = None,
         use_unicode_characters: bool = True,
     ) -> str:
         """Outputs text containing the diagram."""
@@ -357,7 +344,7 @@ class TextDiagramDrawer:
     def vstack(
         cls,
         diagrams: Sequence[cirq.TextDiagramDrawer],
-        padding_resolver: Optional[Callable[[Sequence[Optional[int]]], int]] = None,
+        padding_resolver: Callable[[Sequence[int | None]], int] | None = None,
     ):
         """Vertically stack text diagrams.
 
@@ -386,9 +373,7 @@ class TextDiagramDrawer:
             dy += diagram.height()
         for x in stacked.horizontal_padding:
             resolved_padding = padding_resolver(
-                tuple(
-                    cast(Optional[int], diagram.horizontal_padding.get(x)) for diagram in diagrams
-                )
+                tuple(cast(int | None, diagram.horizontal_padding.get(x)) for diagram in diagrams)
             )
             if resolved_padding is not None:
                 stacked.horizontal_padding[x] = resolved_padding
@@ -398,7 +383,7 @@ class TextDiagramDrawer:
     def hstack(
         cls,
         diagrams: Sequence[cirq.TextDiagramDrawer],
-        padding_resolver: Optional[Callable[[Sequence[Optional[int]]], int]] = None,
+        padding_resolver: Callable[[Sequence[int | None]], int] | None = None,
     ):
         """Horizontally stack text diagrams.
 
@@ -427,7 +412,7 @@ class TextDiagramDrawer:
             dx += diagram.width()
         for y in stacked.vertical_padding:
             resolved_padding = padding_resolver(
-                tuple(cast(Optional[int], diagram.vertical_padding.get(y)) for diagram in diagrams)
+                tuple(cast(int | None, diagram.vertical_padding.get(y)) for diagram in diagrams)
             )
             if resolved_padding is not None:
                 stacked.vertical_padding[y] = resolved_padding

cirq/contrib/acquaintance/bipartite.py

@@ -16,7 +16,7 @@ from __future__ import annotations
 
 import enum
 import itertools
-from typing import Dict, Iterator, Sequence, Tuple, TYPE_CHECKING, Union
+from typing import Iterator, Sequence, TYPE_CHECKING
 
 from cirq import ops
 from cirq.contrib.acquaintance.gates import acquaint
@@ -61,10 +61,7 @@ class BipartiteSwapNetworkGate(PermutationGate):
     """
 
     def __init__(
-        self,
-        subgraph: Union[str, BipartiteGraphType],
-        part_size: int,
-        swap_gate: cirq.Gate = ops.SWAP,
+        self, subgraph: str | BipartiteGraphType, part_size: int, swap_gate: cirq.Gate = ops.SWAP
     ) -> None:
         super().__init__(2 * part_size, swap_gate)
         self.part_size = part_size
@@ -106,7 +103,7 @@ class BipartiteSwapNetworkGate(PermutationGate):
             return self.decompose_matching(qubits)
         raise NotImplementedError('No decomposition implemented for ' + str(self.subgraph))
 
-    def permutation(self) -> Dict[int, int]:
+    def permutation(self) -> dict[int, int]:
         if self.num_qubits() != 2 * self.part_size:
             raise ValueError('qubit_count != 2 * self.part_size')
         if self.subgraph == BipartiteGraphType.MATCHING:
@@ -124,7 +121,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)')
@@ -149,7 +146,7 @@ class BipartiteSwapNetworkGate(PermutationGate):
         return wire_symbols
 
     def __repr__(self) -> str:
-        args: Tuple[str, ...] = (repr(self.subgraph), repr(self.part_size))
+        args: tuple[str, ...] = (repr(self.subgraph), repr(self.part_size))
         if self.swap_gate != ops.SWAP:
             args += (repr(self.swap_gate),)
         args_str = ', '.join(args)

cirq/contrib/acquaintance/executor.py

@@ -16,7 +16,7 @@ from __future__ import annotations
 
 import abc
 from collections import defaultdict
-from typing import DefaultDict, Dict, Iterator, Optional, Sequence, TYPE_CHECKING
+from typing import Iterator, Sequence, TYPE_CHECKING
 
 from cirq import circuits, devices, ops, protocols, transformers
 from cirq.contrib.acquaintance.gates import AcquaintanceOpportunityGate
@@ -99,7 +99,7 @@ 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: cirq.TransformerContext | None = None
     ) -> circuits.Circuit:
         """Executes an acquaintance strategy using cirq.map_operations_and_unroll and
         mutates initial mapping.
@@ -174,7 +174,7 @@ class GreedyExecutionStrategy(ExecutionStrategy):
         self,
         gates: LogicalGates,
         initial_mapping: LogicalMapping,
-        device: Optional[cirq.Device] = None,
+        device: cirq.Device | None = None,
     ) -> None:
         """Inits GreedyExecutionStrategy.
 
@@ -214,13 +214,13 @@ class GreedyExecutionStrategy(ExecutionStrategy):
                 yield gate(*[index_to_qubit[i] for i in gate_indices])
 
     @staticmethod
-    def canonicalize_gates(gates: LogicalGates) -> Dict[frozenset, LogicalGates]:
+    def canonicalize_gates(gates: LogicalGates) -> dict[frozenset, LogicalGates]:
         """Canonicalizes a set of gates by the qubits they act on.
 
         Takes a set of gates specified by ordered sequences of logical
         indices, and groups those that act on the same qubits regardless of
         order."""
-        canonicalized_gates: DefaultDict[frozenset, LogicalGates] = defaultdict(dict)
+        canonicalized_gates: defaultdict[frozenset, LogicalGates] = defaultdict(dict)
         for indices, gate in gates.items():
             indices = tuple(indices)
             canonicalized_gates[frozenset(indices)][indices] = gate

cirq/contrib/acquaintance/executor_test.py

@@ -16,7 +16,7 @@ from __future__ import annotations
 
 from itertools import combinations
 from string import ascii_lowercase
-from typing import Dict, Sequence, Tuple
+from typing import Sequence
 
 import numpy as np
 import pytest
@@ -87,7 +87,7 @@ def test_executor_explicit():
 
 def random_diagonal_gates(
     num_qubits: int, acquaintance_size: int
-) -> Dict[Tuple[cirq.Qid, ...], cirq.Gate]:
+) -> dict[tuple[cirq.Qid, ...], cirq.Gate]:
 
     return {
         Q: cirq.DiagonalGate(np.random.random(2**acquaintance_size))
@@ -106,7 +106,7 @@ def random_diagonal_gates(
     ],
 )
 def test_executor_random(
-    num_qubits: int, acquaintance_size: int, gates: Dict[Tuple[cirq.Qid, ...], cirq.Gate]
+    num_qubits: int, acquaintance_size: int, gates: dict[tuple[cirq.Qid, ...], cirq.Gate]
 ):
     qubits = cirq.LineQubit.range(num_qubits)
     circuit = cca.complete_acquaintance_strategy(qubits, acquaintance_size)

cirq/contrib/acquaintance/gates.py

@@ -18,17 +18,7 @@ import functools
 import itertools
 import math
 import operator
-from typing import (
-    Dict,
-    Iterable,
-    Iterator,
-    List,
-    NamedTuple,
-    Optional,
-    Sequence,
-    Tuple,
-    TYPE_CHECKING,
-)
+from typing import Iterable, Iterator, NamedTuple, Sequence, TYPE_CHECKING
 
 from cirq import ops, protocols, value
 from cirq.contrib.acquaintance.permutation import (
@@ -44,10 +34,10 @@ if TYPE_CHECKING:
 
 def operations_to_part_lens(
     qubit_order: Sequence[cirq.Qid], op_tree: cirq.OP_TREE
-) -> Tuple[int, ...]:
+) -> 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))
 
@@ -87,16 +77,16 @@ def acquaint(*qubits) -> cirq.Operation:
 Layers = NamedTuple(
     'Layers',
     [
-        ('prior_interstitial', List['cirq.Operation']),
-        ('pre', List['cirq.Operation']),
-        ('intra', List['cirq.Operation']),
-        ('post', List['cirq.Operation']),
-        ('posterior_interstitial', List['cirq.Operation']),
+        ('prior_interstitial', list['cirq.Operation']),
+        ('pre', list['cirq.Operation']),
+        ('intra', list['cirq.Operation']),
+        ('post', list['cirq.Operation']),
+        ('posterior_interstitial', list['cirq.Operation']),
     ],
 )
 
 
-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)
 
 
@@ -106,7 +96,7 @@ def acquaint_insides(
     qubits: Sequence[cirq.Qid],
     before: bool,
     layers: Layers,
-    mapping: Dict[ops.Qid, int],
+    mapping: dict[ops.Qid, int],
 ) -> None:
     """Acquaints each of the qubits with another set specified by an
     acquaintance gate.
@@ -153,11 +143,11 @@ 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],
+    acquaintance_size: int | None,
     swap_gate: cirq.Gate,
-    mapping: Dict[ops.Qid, int],
+    mapping: dict[ops.Qid, int],
 ):
     """Acquaints and shifts a pair of lists of qubits. The first part is
     acquainted with every qubit individually in the second part, and vice
@@ -276,7 +266,7 @@ class SwapNetworkGate(PermutationGate):
     def __init__(
         self,
         part_lens: Sequence[int],
-        acquaintance_size: Optional[int] = 0,
+        acquaintance_size: int | None = 0,
         swap_gate: cirq.Gate = ops.SWAP,
     ) -> None:
         super().__init__(sum(part_lens), swap_gate)
@@ -346,13 +336,13 @@ class SwapNetworkGate(PermutationGate):
     def from_operations(
         qubit_order: Sequence[cirq.Qid],
         operations: Sequence[cirq.Operation],
-        acquaintance_size: Optional[int] = 0,
+        acquaintance_size: int | None = 0,
         swap_gate: cirq.Gate = ops.SWAP,
     ) -> SwapNetworkGate:
         part_sizes = operations_to_part_lens(qubit_order, operations)
         return SwapNetworkGate(part_sizes, acquaintance_size, swap_gate)
 
-    def permutation(self) -> Dict[int, int]:
+    def permutation(self) -> dict[int, int]:
         return {i: j for i, j in enumerate(reversed(range(sum(self.part_lens))))}
 
     def __repr__(self) -> str:

cirq/contrib/acquaintance/gates_test.py

@@ -17,7 +17,7 @@ from __future__ import annotations
 from itertools import combinations, product
 from random import randint
 from string import ascii_lowercase as alphabet
-from typing import Optional, Sequence, Tuple
+from typing import Sequence
 
 import numpy
 import pytest
@@ -141,7 +141,7 @@ def test_acquaint_part_pairs(part_lens):
     assert expected_opps == actual_opps
 
 
-acquaintance_sizes: Tuple[Optional[int], ...] = (None,)
+acquaintance_sizes: tuple[int | None, ...] = (None,)
 acquaintance_sizes += tuple(range(5))
 
 
@@ -256,7 +256,7 @@ class OtherOperation(cirq.Operation):
         self._qubits = tuple(qubits)
 
     @property
-    def qubits(self) -> Tuple[cirq.Qid, ...]:
+    def qubits(self) -> tuple[cirq.Qid, ...]:
         return self._qubits
 
     def with_qubits(self, *new_qubits: cirq.Qid) -> OtherOperation:

cirq/contrib/acquaintance/mutation_utils.py

@@ -15,7 +15,7 @@
 from __future__ import annotations
 
 import collections
-from typing import cast, Dict, List, Optional, Sequence, TYPE_CHECKING, Union
+from typing import cast, Sequence, TYPE_CHECKING
 
 from cirq import circuits, ops, transformers
 from cirq.contrib.acquaintance.devices import get_acquaintance_size
@@ -25,7 +25,7 @@ from cirq.contrib.acquaintance.permutation import PermutationGate
 if TYPE_CHECKING:
     import cirq
 
-STRATEGY_GATE = Union[AcquaintanceOpportunityGate, PermutationGate]
+STRATEGY_GATE = AcquaintanceOpportunityGate | PermutationGate
 
 
 def rectify_acquaintance_strategy(circuit: cirq.Circuit, acquaint_first: bool = True) -> None:
@@ -43,7 +43,7 @@ def rectify_acquaintance_strategy(circuit: cirq.Circuit, acquaint_first: bool =
     """
     rectified_moments = []
     for moment in circuit:
-        gate_type_to_ops: Dict[bool, List[ops.GateOperation]] = collections.defaultdict(list)
+        gate_type_to_ops: dict[bool, list[ops.GateOperation]] = collections.defaultdict(list)
         for op in moment.operations:
             gate_op = cast(ops.GateOperation, op)
             is_acquaintance = isinstance(gate_op.gate, AcquaintanceOpportunityGate)
@@ -59,7 +59,7 @@ def rectify_acquaintance_strategy(circuit: cirq.Circuit, acquaint_first: bool =
 def replace_acquaintance_with_swap_network(
     circuit: cirq.Circuit,
     qubit_order: Sequence[cirq.Qid],
-    acquaintance_size: Optional[int] = 0,
+    acquaintance_size: int | None = 0,
     swap_gate: cirq.Gate = ops.SWAP,
 ) -> bool:
     """Replace every rectified moment with acquaintance gates with a generalized swap network.

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/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.