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

cirq/transformers/qubit_management_transformers.py

@@ -14,7 +14,7 @@
 
 from __future__ import annotations
 
-from typing import Dict, Optional, Set, Tuple, TYPE_CHECKING
+from typing import TYPE_CHECKING
 
 from cirq import circuits, ops
 
@@ -24,7 +24,7 @@ if TYPE_CHECKING:
 
 def _get_qubit_mapping_first_and_last_moment(
     circuit: cirq.AbstractCircuit,
-) -> Dict[cirq.Qid, Tuple[int, int]]:
+) -> dict[cirq.Qid, tuple[int, int]]:
     """Computes `(first_moment_idx, last_moment_idx)` tuple for each qubit in the input circuit.
 
     Args:
@@ -48,7 +48,7 @@ def _is_temp(q: cirq.Qid) -> bool:
 
 
 def map_clean_and_borrowable_qubits(
-    circuit: cirq.AbstractCircuit, *, qm: Optional[cirq.QubitManager] = None
+    circuit: cirq.AbstractCircuit, *, qm: cirq.QubitManager | None = None
 ) -> cirq.Circuit:
     """Uses `qm: QubitManager` to map all `CleanQubit`/`BorrowableQubit`s to system qubits.
 
@@ -99,8 +99,8 @@ def map_clean_and_borrowable_qubits(
     trivial_map = {q: q for q in all_qubits}
     # `allocated_map` maintains the mapping of all temporary qubits seen so far, mapping each of
     # them to either a newly allocated managed ancilla or an existing borrowed system qubit.
-    allocated_map: Dict[cirq.Qid, cirq.Qid] = {}
-    to_free: Set[cirq.Qid] = set()
+    allocated_map: dict[cirq.Qid, cirq.Qid] = {}
+    to_free: set[cirq.Qid] = set()
     last_op_idx = -1
 
     def map_func(op: cirq.Operation, idx: int) -> cirq.OP_TREE:

cirq/transformers/routing/initial_mapper.py

@@ -15,7 +15,7 @@
 from __future__ import annotations
 
 import abc
-from typing import Dict, TYPE_CHECKING
+from typing import TYPE_CHECKING
 
 from cirq import value
 
@@ -39,7 +39,7 @@ class AbstractInitialMapper(metaclass=abc.ABCMeta):
     """
 
     @abc.abstractmethod
-    def initial_mapping(self, circuit: cirq.AbstractCircuit) -> Dict[cirq.Qid, cirq.Qid]:
+    def initial_mapping(self, circuit: cirq.AbstractCircuit) -> dict[cirq.Qid, cirq.Qid]:
         """Maps the logical qubits of a circuit onto physical qubits on a device.
 
         Args:
@@ -54,10 +54,10 @@ class AbstractInitialMapper(metaclass=abc.ABCMeta):
 class HardCodedInitialMapper(AbstractInitialMapper):
     """Initial Mapper class takes a hard-coded mapping and returns it."""
 
-    def __init__(self, _map: Dict[cirq.Qid, cirq.Qid]) -> None:
+    def __init__(self, _map: dict[cirq.Qid, cirq.Qid]) -> None:
         self._map = _map
 
-    def initial_mapping(self, circuit: cirq.AbstractCircuit) -> Dict[cirq.Qid, cirq.Qid]:
+    def initial_mapping(self, circuit: cirq.AbstractCircuit) -> dict[cirq.Qid, cirq.Qid]:
         """Returns the hard-coded initial mapping.
 
         Args:

cirq/transformers/routing/line_initial_mapper.py

@@ -33,7 +33,7 @@ If some logical qubits are unampped after this first procedure then there are tw
 from __future__ import annotations
 
 from collections import deque
-from typing import Deque, Dict, List, Set, Tuple, TYPE_CHECKING
+from typing import TYPE_CHECKING
 
 import networkx as nx
 
@@ -85,7 +85,7 @@ class LineInitialMapper(initial_mapper.AbstractInitialMapper):
 
     def _make_circuit_graph(
         self, circuit: cirq.AbstractCircuit
-    ) -> Tuple[List[Deque[cirq.Qid]], Dict[cirq.Qid, cirq.Qid]]:
+    ) -> tuple[list[deque[cirq.Qid]], dict[cirq.Qid, cirq.Qid]]:
         """Creates a (potentially incomplete) qubit connectivity graph of the circuit.
 
         Iterates over moments in the circuit from left to right and adds edges between logical
@@ -101,9 +101,9 @@ class LineInitialMapper(initial_mapper.AbstractInitialMapper):
             The (potentially incomplete) qubit connectivity graph of the circuit, which is
                 guaranteed to be a forest of line graphs.
         """
-        circuit_graph: List[Deque[cirq.Qid]] = [deque([q]) for q in sorted(circuit.all_qubits())]
-        component_id: Dict[cirq.Qid, int] = {q[0]: i for i, q in enumerate(circuit_graph)}
-        partners: Dict[cirq.Qid, cirq.Qid] = {}
+        circuit_graph: list[deque[cirq.Qid]] = [deque([q]) for q in sorted(circuit.all_qubits())]
+        component_id: dict[cirq.Qid, int] = {q[0]: i for i, q in enumerate(circuit_graph)}
+        partners: dict[cirq.Qid, cirq.Qid] = {}
 
         def degree_lt_two(q: cirq.Qid):
             return any(circuit_graph[component_id[q]][i] == q for i in [-1, 0])
@@ -143,7 +143,7 @@ class LineInitialMapper(initial_mapper.AbstractInitialMapper):
         )
         return graph, partners
 
-    def initial_mapping(self, circuit: cirq.AbstractCircuit) -> Dict[cirq.Qid, cirq.Qid]:
+    def initial_mapping(self, circuit: cirq.AbstractCircuit) -> dict[cirq.Qid, cirq.Qid]:
         """Maps disjoint lines of logical qubits onto lines of physical qubits.
 
         Args:
@@ -153,8 +153,8 @@ class LineInitialMapper(initial_mapper.AbstractInitialMapper):
             a dictionary that maps logical qubits in the circuit (keys) to physical qubits on the
             device (values).
         """
-        mapped_physicals: Set[cirq.Qid] = set()
-        qubit_map: Dict[cirq.Qid, cirq.Qid] = {}
+        mapped_physicals: set[cirq.Qid] = set()
+        qubit_map: dict[cirq.Qid, cirq.Qid] = {}
         circuit_graph, partners = self._make_circuit_graph(circuit)
 
         def next_physical(
@@ -191,7 +191,7 @@ class LineInitialMapper(initial_mapper.AbstractInitialMapper):
         return qubit_map
 
     def _closest_unmapped_qubit(
-        self, source: cirq.Qid, mapped_physicals: Set[cirq.Qid]
+        self, source: cirq.Qid, mapped_physicals: set[cirq.Qid]
     ) -> cirq.Qid:
         """Finds the closest available neighbor to a physical qubit 'source' on the device.
 

cirq/transformers/routing/mapping_manager.py

@@ -16,7 +16,7 @@
 
 from __future__ import annotations
 
-from typing import Dict, List, Sequence, TYPE_CHECKING
+from typing import Sequence, TYPE_CHECKING
 
 import networkx as nx
 import numpy as np
@@ -37,7 +37,7 @@ class MappingManager:
     logical qubits are mapped to, via `self.logical_qid_to_int` map).
     """
 
-    def __init__(self, device_graph: nx.Graph, initial_mapping: Dict[cirq.Qid, cirq.Qid]) -> None:
+    def __init__(self, device_graph: nx.Graph, initial_mapping: dict[cirq.Qid, cirq.Qid]) -> None:
         """Initializes MappingManager.
 
         Args:
@@ -84,12 +84,12 @@ class MappingManager:
         )
 
     @property
-    def physical_qid_to_int(self) -> Dict[cirq.Qid, int]:
+    def physical_qid_to_int(self) -> dict[cirq.Qid, int]:
         """Mapping of physical qubits, that were part of the initial mapping, to unique integers."""
         return self._physical_qid_to_int
 
     @property
-    def int_to_physical_qid(self) -> List[cirq.Qid]:
+    def int_to_physical_qid(self) -> list[cirq.Qid]:
         """Inverse mapping of unique integers to corresponding physical qubits.
 
         `self.physical_qid_to_int[self.int_to_physical_qid[i]] == i` for each i.
@@ -97,12 +97,12 @@ class MappingManager:
         return self._int_to_physical_qid
 
     @property
-    def logical_qid_to_int(self) -> Dict[cirq.Qid, int]:
+    def logical_qid_to_int(self) -> dict[cirq.Qid, int]:
         """Mapping of logical qubits, that were part of the initial mapping, to unique integers."""
         return self._logical_qid_to_int
 
     @property
-    def int_to_logical_qid(self) -> List[cirq.Qid]:
+    def int_to_logical_qid(self) -> list[cirq.Qid]:
         """Inverse mapping of unique integers to corresponding physical qubits.
 
         `self.logical_qid_to_int[self.int_to_logical_qid[i]] == i` for each i.
@@ -189,7 +189,7 @@ class MappingManager:
         """
         logical_ints = [self._logical_qid_to_int[q] for q in op.qubits]
         physical_ints = self.logical_to_physical[logical_ints]
-        qubit_map: Dict[cirq.Qid, cirq.Qid] = {
+        qubit_map: dict[cirq.Qid, cirq.Qid] = {
             q: self._int_to_physical_qid[physical_ints[i]] for i, q in enumerate(op.qubits)
         }
         return op.transform_qubits(qubit_map)

cirq/transformers/routing/route_circuit_cqc.py

@@ -17,7 +17,7 @@
 from __future__ import annotations
 
 import itertools
-from typing import Any, Dict, List, Optional, Sequence, Set, Tuple, TYPE_CHECKING
+from typing import Any, Sequence, TYPE_CHECKING
 
 import networkx as nx
 
@@ -28,12 +28,12 @@ from cirq.transformers.routing import line_initial_mapper, mapping_manager
 if TYPE_CHECKING:
     import cirq
 
-QidIntPair = Tuple[int, int]
+QidIntPair = tuple[int, int]
 
 
 def _disjoint_nc2_combinations(
     qubit_pairs: Sequence[QidIntPair],
-) -> List[Tuple[QidIntPair, QidIntPair]]:
+) -> list[tuple[QidIntPair, QidIntPair]]:
     """Gets disjoint pair combinations of qubits pairs.
 
     For example:
@@ -114,8 +114,8 @@ class RouteCQC:
         *,
         lookahead_radius: int = 8,
         tag_inserted_swaps: bool = False,
-        initial_mapper: Optional[cirq.AbstractInitialMapper] = None,
-        context: Optional[cirq.TransformerContext] = None,
+        initial_mapper: cirq.AbstractInitialMapper | None = None,
+        context: cirq.TransformerContext | None = None,
     ) -> cirq.AbstractCircuit:
         """Transforms the given circuit to make it executable on the device.
 
@@ -156,9 +156,9 @@ class RouteCQC:
         *,
         lookahead_radius: int = 8,
         tag_inserted_swaps: bool = False,
-        initial_mapper: Optional[cirq.AbstractInitialMapper] = None,
-        context: Optional[cirq.TransformerContext] = None,
-    ) -> Tuple[cirq.AbstractCircuit, Dict[cirq.Qid, cirq.Qid], Dict[cirq.Qid, cirq.Qid]]:
+        initial_mapper: cirq.AbstractInitialMapper | None = None,
+        context: cirq.TransformerContext | None = None,
+    ) -> tuple[cirq.AbstractCircuit, dict[cirq.Qid, cirq.Qid], dict[cirq.Qid, cirq.Qid]]:
         """Transforms the given circuit to make it executable on the device.
 
         This transformer assumes that all multi-qubit operations have been decomposed into 2-qubit
@@ -244,7 +244,7 @@ class RouteCQC:
     @classmethod
     def _get_one_and_two_qubit_ops_as_timesteps(
         cls, circuit: cirq.AbstractCircuit
-    ) -> Tuple[List[List[cirq.Operation]], List[List[cirq.Operation]]]:
+    ) -> tuple[list[list[cirq.Operation]], list[list[cirq.Operation]]]:
         """Gets the single and two qubit operations of the circuit factored into timesteps.
 
         The i'th entry in the nested two-qubit and single-qubit ops correspond to the two-qubit
@@ -256,7 +256,7 @@ class RouteCQC:
                         qubits with a custom key.
         """
         two_qubit_circuit = circuits.Circuit()
-        single_qubit_ops: List[List[cirq.Operation]] = []
+        single_qubit_ops: list[list[cirq.Operation]] = []
 
         for i, moment in enumerate(circuit):
             for op in moment:
@@ -288,11 +288,11 @@ class RouteCQC:
     def _route(
         cls,
         mm: mapping_manager.MappingManager,
-        two_qubit_ops: List[List[cirq.Operation]],
-        single_qubit_ops: List[List[cirq.Operation]],
+        two_qubit_ops: list[list[cirq.Operation]],
+        single_qubit_ops: list[list[cirq.Operation]],
         lookahead_radius: int,
         tag_inserted_swaps: bool = False,
-    ) -> List[List[cirq.Operation]]:
+    ) -> list[list[cirq.Operation]]:
         """Main routing procedure that inserts necessary swaps on the given timesteps.
 
         The i'th element of the returned list corresponds to the routed operatiosn in the i'th
@@ -311,18 +311,18 @@ class RouteCQC:
         Returns:
             a list of lists corresponding to timesteps of the routed circuit.
         """
-        two_qubit_ops_ints: List[List[QidIntPair]] = [
+        two_qubit_ops_ints: list[list[QidIntPair]] = [
             [
                 (mm.logical_qid_to_int[op.qubits[0]], mm.logical_qid_to_int[op.qubits[1]])
                 for op in timestep_ops
             ]
             for timestep_ops in two_qubit_ops
         ]
-        routed_ops: List[List[cirq.Operation]] = []
+        routed_ops: list[list[cirq.Operation]] = []
 
         def process_executable_two_qubit_ops(timestep: int) -> int:
-            unexecutable_ops: List[cirq.Operation] = []
-            unexecutable_ops_ints: List[QidIntPair] = []
+            unexecutable_ops: list[cirq.Operation] = []
+            unexecutable_ops_ints: list[QidIntPair] = []
             for op, op_ints in zip(two_qubit_ops[timestep], two_qubit_ops_ints[timestep]):
                 if mm.is_adjacent(*op_ints):
                     routed_ops[timestep].append(mm.mapped_op(op))
@@ -341,10 +341,10 @@ class RouteCQC:
 
             # swaps applied in the current timestep thus far. This ensures the same swaps
             # don't get executed twice in the same timestep.
-            seen: Set[Tuple[QidIntPair, ...]] = set()
+            seen: set[tuple[QidIntPair, ...]] = set()
 
             while process_executable_two_qubit_ops(timestep):
-                chosen_swaps: Optional[Tuple[QidIntPair, ...]] = None
+                chosen_swaps: tuple[QidIntPair, ...] | None = None
                 for strat in strats:
                     chosen_swaps = strat(mm, two_qubit_ops_ints, timestep, lookahead_radius)
                     if chosen_swaps is not None:
@@ -372,7 +372,7 @@ class RouteCQC:
         mm: mapping_manager.MappingManager,
         two_qubit_ops_ints: Sequence[Sequence[QidIntPair]],
         timestep: int,
-    ) -> Tuple[QidIntPair, ...]:
+    ) -> tuple[QidIntPair, ...]:
         """Inserts SWAPS along the shortest path of the qubits that are the farthest.
 
         Since swaps along the shortest path are being executed one after the other, in order
@@ -390,7 +390,7 @@ class RouteCQC:
         two_qubit_ops_ints: Sequence[Sequence[QidIntPair]],
         timestep: int,
         lookahead_radius: int,
-    ) -> Optional[Tuple[QidIntPair, ...]]:
+    ) -> tuple[QidIntPair, ...] | None:
         """Computes cost function with pairs of candidate swaps that act on disjoint qubits."""
         pair_sigma = _disjoint_nc2_combinations(
             cls._initial_candidate_swaps(mm, two_qubit_ops_ints[timestep])
@@ -406,9 +406,9 @@ class RouteCQC:
         two_qubit_ops_ints: Sequence[Sequence[QidIntPair]],
         timestep: int,
         lookahead_radius: int,
-    ) -> Optional[Tuple[QidIntPair, ...]]:
+    ) -> tuple[QidIntPair, ...] | None:
         """Computes cost function with list of single candidate swaps."""
-        sigma: List[Tuple[QidIntPair, ...]] = [
+        sigma: list[tuple[QidIntPair, ...]] = [
             (swap,) for swap in cls._initial_candidate_swaps(mm, two_qubit_ops_ints[timestep])
         ]
         return cls._choose_optimal_swap(mm, two_qubit_ops_ints, timestep, lookahead_radius, sigma)
@@ -420,8 +420,8 @@ class RouteCQC:
         two_qubit_ops_ints: Sequence[Sequence[QidIntPair]],
         timestep: int,
         lookahead_radius: int,
-        sigma: Sequence[Tuple[QidIntPair, ...]],
-    ) -> Optional[Tuple[QidIntPair, ...]]:
+        sigma: Sequence[tuple[QidIntPair, ...]],
+    ) -> tuple[QidIntPair, ...] | None:
         """Optionally returns the swap with minimum cost from a list of n-tuple candidate swaps.
 
         Computes a cost (as defined by the overridable function `_cost`) for each candidate swap
@@ -449,7 +449,7 @@ class RouteCQC:
     @classmethod
     def _initial_candidate_swaps(
         cls, mm: mapping_manager.MappingManager, two_qubit_ops: Sequence[QidIntPair]
-    ) -> List[QidIntPair]:
+    ) -> list[QidIntPair]:
         """Finds all feasible SWAPs between qubits involved in 2-qubit operations."""
         physical_qubits = (mm.logical_to_physical[lq[i]] for lq in two_qubit_ops for i in range(2))
         physical_swaps = mm.induced_subgraph_int.edges(nbunch=physical_qubits)
@@ -461,7 +461,7 @@ class RouteCQC:
     def _cost(
         cls,
         mm: mapping_manager.MappingManager,
-        swaps: Tuple[QidIntPair, ...],
+        swaps: tuple[QidIntPair, ...],
         two_qubit_ops: Sequence[QidIntPair],
     ) -> Any:
         """Computes the cost function for the given list of swaps over the current timestep ops.

cirq/transformers/routing/visualize_routed_circuit.py

@@ -14,7 +14,7 @@
 
 from __future__ import annotations
 
-from typing import Dict, Optional, Tuple, TYPE_CHECKING
+from typing import TYPE_CHECKING
 
 from cirq import circuits, ops
 
@@ -25,18 +25,18 @@ if TYPE_CHECKING:
 class _SwapPrintGate(ops.Gate):
     """A gate that displays the string representation of each qubits on the circuit."""
 
-    def __init__(self, qubits: Tuple[Tuple[cirq.Qid, cirq.Qid], ...]) -> None:
+    def __init__(self, qubits: tuple[tuple[cirq.Qid, cirq.Qid], ...]) -> None:
         self.qubits = qubits
 
     def num_qubits(self):
         return len(self.qubits)
 
-    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> Tuple[str, ...]:
+    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> tuple[str, ...]:
         return tuple(f'{str(q[1])}' for q in self.qubits)
 
 
 def routed_circuit_with_mapping(
-    routed_circuit: cirq.AbstractCircuit, initial_map: Optional[Dict[cirq.Qid, cirq.Qid]] = None
+    routed_circuit: cirq.AbstractCircuit, initial_map: dict[cirq.Qid, cirq.Qid] | None = None
 ) -> cirq.AbstractCircuit:
     """Returns the same circuits with information about the permutation of qubits after each swap.
 

cirq/transformers/stratify.py

@@ -17,7 +17,7 @@
 from __future__ import annotations
 
 import itertools
-from typing import Callable, Dict, Iterable, List, Optional, Sequence, Type, TYPE_CHECKING, Union
+from typing import Callable, Iterable, Sequence, TYPE_CHECKING, Union
 
 from cirq import _import, circuits, ops, protocols
 from cirq.transformers import transformer_api
@@ -33,7 +33,7 @@ Classifier = Callable[['cirq.Operation'], bool]
 
 # Any of the possible operation categories that we can stratify on.
 Category = Union[
-    'cirq.Gate', 'cirq.Operation', Type['cirq.Gate'], Type['cirq.Operation'], Classifier
+    'cirq.Gate', 'cirq.Operation', type['cirq.Gate'], type['cirq.Operation'], Classifier
 ]
 
 
@@ -41,7 +41,7 @@ Category = Union[
 def stratified_circuit(
     circuit: cirq.AbstractCircuit,
     *,
-    context: Optional[cirq.TransformerContext] = None,
+    context: cirq.TransformerContext | None = None,
     categories: Iterable[Category] = (),
 ) -> cirq.Circuit:
     """Repacks avoiding simultaneous operations with different classes.
@@ -117,12 +117,12 @@ def _stratify_circuit(
         The stratified circuit.
     """
     num_classes = len(classifiers) + 1  # include one "extra" category for ignored operations
-    new_moments: List[List[cirq.Operation]] = []
+    new_moments: list[list[cirq.Operation]] = []
 
     # Keep track of the latest time index for each qubit, measurement key, and control key.
-    qubit_time_index: Dict[cirq.Qid, int] = {}
-    measurement_time_index: Dict[cirq.MeasurementKey, int] = {}
-    control_time_index: Dict[cirq.MeasurementKey, int] = {}
+    qubit_time_index: dict[cirq.Qid, int] = {}
+    measurement_time_index: dict[cirq.MeasurementKey, int] = {}
+    control_time_index: dict[cirq.MeasurementKey, int] = {}
 
     # The minimum time index for operations with a tag in context.tags_to_ignore.
     last_ignored_ops_time_index = 0
@@ -177,7 +177,7 @@ def _stratify_circuit(
 
 def _get_classifiers(
     circuit: circuits.AbstractCircuit, categories: Iterable[Category]
-) -> List[Classifier]:
+) -> list[Classifier]:
     """Convert a collection of categories into a list of classifiers.
 
     The returned list of classifiers is:

cirq/transformers/synchronize_terminal_measurements.py

@@ -16,7 +16,7 @@
 
 from __future__ import annotations
 
-from typing import List, Optional, Set, Tuple, TYPE_CHECKING
+from typing import TYPE_CHECKING
 
 from cirq import circuits, protocols
 from cirq.transformers import transformer_api
@@ -25,7 +25,7 @@ if TYPE_CHECKING:
     import cirq
 
 
-def find_terminal_measurements(circuit: cirq.AbstractCircuit) -> List[Tuple[int, cirq.Operation]]:
+def find_terminal_measurements(circuit: cirq.AbstractCircuit) -> list[tuple[int, cirq.Operation]]:
     """Finds all terminal measurements in the given circuit.
 
     A measurement is terminal if there are no other operations acting on the measured qubits
@@ -39,9 +39,9 @@ def find_terminal_measurements(circuit: cirq.AbstractCircuit) -> List[Tuple[int,
         (moment_index, measurement_operation).
     """
 
-    open_qubits: Set[cirq.Qid] = set(circuit.all_qubits())
-    seen_control_keys: Set[cirq.MeasurementKey] = set()
-    terminal_measurements: Set[Tuple[int, cirq.Operation]] = set()
+    open_qubits: set[cirq.Qid] = set(circuit.all_qubits())
+    seen_control_keys: set[cirq.MeasurementKey] = set()
+    terminal_measurements: set[tuple[int, cirq.Operation]] = set()
     for i in range(len(circuit) - 1, -1, -1):
         moment = circuit[i]
         for q in open_qubits:
@@ -64,7 +64,7 @@ def find_terminal_measurements(circuit: cirq.AbstractCircuit) -> List[Tuple[int,
 def synchronize_terminal_measurements(
     circuit: cirq.AbstractCircuit,
     *,
-    context: Optional[cirq.TransformerContext] = None,
+    context: cirq.TransformerContext | None = None,
     after_other_operations: bool = True,
 ) -> cirq.Circuit:
     """Move measurements to the end of the circuit.

cirq/transformers/target_gatesets/compilation_target_gateset.py

@@ -17,7 +17,7 @@
 from __future__ import annotations
 
 import abc
-from typing import Hashable, List, Optional, Type, TYPE_CHECKING, Union
+from typing import Hashable, TYPE_CHECKING
 
 from cirq import circuits, ops, protocols, transformers
 from cirq.transformers import merge_k_qubit_gates, merge_single_qubit_gates
@@ -67,7 +67,7 @@ def create_transformer_with_kwargs(transformer: cirq.TRANSFORMER, **kwargs) -> c
         raise SyntaxError('**kwargs to be captured must not contain `context`.')
 
     def transformer_with_kwargs(
-        circuit: cirq.AbstractCircuit, *, context: Optional[cirq.TransformerContext] = None
+        circuit: cirq.AbstractCircuit, *, context: cirq.TransformerContext | None = None
     ) -> cirq.AbstractCircuit:
         return transformer(circuit, context=context, **kwargs)
 
@@ -83,8 +83,8 @@ class CompilationTargetGateset(ops.Gateset, metaclass=abc.ABCMeta):
 
     def __init__(
         self,
-        *gates: Union[Type[cirq.Gate], cirq.Gate, cirq.GateFamily],
-        name: Optional[str] = None,
+        *gates: type[cirq.Gate] | cirq.Gate | cirq.GateFamily,
+        name: str | None = None,
         unroll_circuit_op: bool = True,
         preserve_moment_structure: bool = True,
         reorder_operations: bool = False,
@@ -155,7 +155,7 @@ class CompilationTargetGateset(ops.Gateset, metaclass=abc.ABCMeta):
         return "_default_merged_k_qubit_unitaries"
 
     @property
-    def preprocess_transformers(self) -> List[cirq.TRANSFORMER]:
+    def preprocess_transformers(self) -> list[cirq.TRANSFORMER]:
         """List of transformers which should be run before decomposing individual operations."""
         reorder_transfomers = (
             [transformers.insertion_sort_transformer] if self._reorder_operations else []
@@ -174,9 +174,9 @@ class CompilationTargetGateset(ops.Gateset, metaclass=abc.ABCMeta):
         ]
 
     @property
-    def postprocess_transformers(self) -> List[cirq.TRANSFORMER]:
+    def postprocess_transformers(self) -> list[cirq.TRANSFORMER]:
         """List of transformers which should be run after decomposing individual operations."""
-        processors: List[cirq.TRANSFORMER] = [
+        processors: list[cirq.TRANSFORMER] = [
             merge_single_qubit_gates.merge_single_qubit_moments_to_phxz,
             transformers.drop_negligible_operations,
             transformers.drop_empty_moments,
@@ -250,7 +250,7 @@ class TwoQubitCompilationTargetGateset(CompilationTargetGateset):
         )
         if switch_to_new:
             return new_optree
-        mapped_old_optree: List[cirq.OP_TREE] = []
+        mapped_old_optree: list[cirq.OP_TREE] = []
         for old_op in ops.flatten_to_ops(old_optree):
             if old_op in self:
                 mapped_old_optree.append(old_op)

cirq/transformers/target_gatesets/compilation_target_gateset_test.py

@@ -14,7 +14,7 @@
 
 from __future__ import annotations
 
-from typing import List, TYPE_CHECKING
+from typing import TYPE_CHECKING
 
 import pytest
 
@@ -37,7 +37,7 @@ def test_compilation_target_gateset() -> None:
             return op if cirq.num_qubits(op) == 2 and cirq.has_unitary(op) else NotImplemented
 
         @property
-        def preprocess_transformers(self) -> List[cirq.TRANSFORMER]:
+        def preprocess_transformers(self) -> list[cirq.TRANSFORMER]:
             return []
 
     gateset = ExampleTargetGateset()

cirq/transformers/target_gatesets/cz_gateset.py

@@ -16,7 +16,7 @@
 
 from __future__ import annotations
 
-from typing import Any, Dict, Sequence, Type, TYPE_CHECKING, Union
+from typing import Any, Sequence, TYPE_CHECKING
 
 from cirq import ops, protocols
 from cirq.transformers.analytical_decompositions import two_qubit_to_cz
@@ -49,7 +49,7 @@ class CZTargetGateset(compilation_target_gateset.TwoQubitCompilationTargetGatese
         *,
         atol: float = 1e-8,
         allow_partial_czs: bool = False,
-        additional_gates: Sequence[Union[Type[cirq.Gate], cirq.Gate, cirq.GateFamily]] = (),
+        additional_gates: Sequence[type[cirq.Gate] | cirq.Gate | cirq.GateFamily] = (),
         preserve_moment_structure: bool = True,
         reorder_operations: bool = False,
     ) -> None:
@@ -108,8 +108,8 @@ class CZTargetGateset(compilation_target_gateset.TwoQubitCompilationTargetGatese
     def _value_equality_values_(self) -> Any:
         return self.atol, self.allow_partial_czs, frozenset(self.additional_gates)
 
-    def _json_dict_(self) -> Dict[str, Any]:
-        d: Dict[str, Any] = {'atol': self.atol, 'allow_partial_czs': self.allow_partial_czs}
+    def _json_dict_(self) -> dict[str, Any]:
+        d: dict[str, Any] = {'atol': self.atol, 'allow_partial_czs': self.allow_partial_czs}
         if self.additional_gates:
             d['additional_gates'] = list(self.additional_gates)
         return d

cirq/transformers/target_gatesets/sqrt_iswap_gateset.py

@@ -16,7 +16,7 @@
 
 from __future__ import annotations
 
-from typing import Any, Dict, Optional, Sequence, Type, TYPE_CHECKING, Union
+from typing import Any, Sequence, TYPE_CHECKING
 
 from cirq import ops, protocols
 from cirq.transformers.analytical_decompositions import two_qubit_to_sqrt_iswap
@@ -49,9 +49,9 @@ class SqrtIswapTargetGateset(compilation_target_gateset.TwoQubitCompilationTarge
         self,
         *,
         atol: float = 1e-8,
-        required_sqrt_iswap_count: Optional[int] = None,
+        required_sqrt_iswap_count: int | None = None,
         use_sqrt_iswap_inv: bool = False,
-        additional_gates: Sequence[Union[Type[cirq.Gate], cirq.Gate, cirq.GateFamily]] = (),
+        additional_gates: Sequence[type[cirq.Gate] | cirq.Gate | cirq.GateFamily] = (),
     ):
         """Initializes `cirq.SqrtIswapTargetGateset`
 
@@ -125,8 +125,8 @@ class SqrtIswapTargetGateset(compilation_target_gateset.TwoQubitCompilationTarge
             frozenset(self.additional_gates),
         )
 
-    def _json_dict_(self) -> Dict[str, Any]:
-        d: Dict[str, Any] = {
+    def _json_dict_(self) -> dict[str, Any]:
+        d: dict[str, Any] = {
             'atol': self.atol,
             'required_sqrt_iswap_count': self.required_sqrt_iswap_count,
             'use_sqrt_iswap_inv': self.use_sqrt_iswap_inv,