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

cirq/transformers/transformer_api.py

@@ -21,20 +21,7 @@ import enum
 import functools
 import inspect
 import textwrap
-from typing import (
-    Any,
-    Callable,
-    cast,
-    Hashable,
-    List,
-    Optional,
-    overload,
-    Tuple,
-    Type,
-    TYPE_CHECKING,
-    TypeVar,
-    Union,
-)
+from typing import Any, Callable, cast, Hashable, overload, TYPE_CHECKING, TypeVar
 
 from typing_extensions import Protocol
 
@@ -87,8 +74,8 @@ class _LoggerNode:
     transformer_name: str
     initial_circuit: cirq.AbstractCircuit
     final_circuit: cirq.AbstractCircuit
-    logs: List[Tuple[LogLevel, Tuple[str, ...]]] = dataclasses.field(default_factory=list)
-    nested_loggers: List[int] = dataclasses.field(default_factory=list)
+    logs: list[tuple[LogLevel, tuple[str, ...]]] = dataclasses.field(default_factory=list)
+    nested_loggers: list[int] = dataclasses.field(default_factory=list)
 
 
 class TransformerLogger:
@@ -115,8 +102,8 @@ class TransformerLogger:
     def __init__(self) -> None:
         """Initializes TransformerLogger."""
         self._curr_id: int = 0
-        self._logs: List[_LoggerNode] = []
-        self._stack: List[int] = []
+        self._logs: list[_LoggerNode] = []
+        self._stack: list[int] = []
 
     def register_initial(self, circuit: cirq.AbstractCircuit, transformer_name: str) -> None:
         """Register the beginning of a new transformer stage.
@@ -227,7 +214,7 @@ class TransformerContext:
     """
 
     logger: TransformerLogger = NoOpTransformerLogger()
-    tags_to_ignore: Tuple[Hashable, ...] = ()
+    tags_to_ignore: tuple[Hashable, ...] = ()
     deep: bool = False
 
 
@@ -264,15 +251,13 @@ class TRANSFORMER(Protocol):
     """
 
     def __call__(
-        self, circuit: cirq.AbstractCircuit, *, context: Optional[TransformerContext] = None
+        self, circuit: cirq.AbstractCircuit, *, context: TransformerContext | None = None
     ) -> cirq.AbstractCircuit: ...
 
 
 _TRANSFORMER_T = TypeVar('_TRANSFORMER_T', bound=TRANSFORMER)
-_TRANSFORMER_CLS_T = TypeVar('_TRANSFORMER_CLS_T', bound=Type[TRANSFORMER])
-_TRANSFORMER_OR_CLS_T = TypeVar(
-    '_TRANSFORMER_OR_CLS_T', bound=Union[TRANSFORMER, Type[TRANSFORMER]]
-)
+_TRANSFORMER_CLS_T = TypeVar('_TRANSFORMER_CLS_T', bound=type[TRANSFORMER])
+_TRANSFORMER_OR_CLS_T = TypeVar('_TRANSFORMER_OR_CLS_T', bound=TRANSFORMER | type[TRANSFORMER])
 
 
 @overload
@@ -404,7 +389,7 @@ def _run_transformer_on_circuit(
     add_deep_support: bool,
     func: TRANSFORMER,
     circuit: cirq.AbstractCircuit,
-    extracted_context: Optional[TransformerContext],
+    extracted_context: TransformerContext | None,
     **kwargs,
 ) -> cirq.AbstractCircuit:
     mutable_circuit = None
@@ -432,7 +417,7 @@ def _transform_and_log(
     func: TRANSFORMER,
     transformer_name: str,
     circuit: cirq.AbstractCircuit,
-    extracted_context: Optional[TransformerContext],
+    extracted_context: TransformerContext | None,
     **kwargs,
 ) -> cirq.AbstractCircuit:
     """Helper to log initial and final circuits before and after calling the transformer."""

cirq/transformers/transformer_primitives.py

@@ -19,19 +19,7 @@ from __future__ import annotations
 import bisect
 import dataclasses
 from collections import defaultdict
-from typing import (
-    Callable,
-    cast,
-    Dict,
-    Hashable,
-    List,
-    Optional,
-    Sequence,
-    Set,
-    Tuple,
-    TYPE_CHECKING,
-    Union,
-)
+from typing import Callable, cast, Hashable, Sequence, TYPE_CHECKING
 
 from cirq import circuits, ops, protocols
 from cirq.circuits.circuit import CIRCUIT_TYPE
@@ -63,7 +51,7 @@ def _create_target_circuit_type(ops: ops.OP_TREE, target_circuit: CIRCUIT_TYPE)
 
 def map_moments(
     circuit: CIRCUIT_TYPE,
-    map_func: Callable[[circuits.Moment, int], Union[circuits.Moment, Sequence[circuits.Moment]]],
+    map_func: Callable[[circuits.Moment, int], circuits.Moment | Sequence[circuits.Moment]],
     *,
     tags_to_ignore: Sequence[Hashable] = (),
     deep: bool = False,
@@ -159,7 +147,7 @@ def _map_operations_impl(
     """
     tags_to_ignore_set = set(tags_to_ignore)
 
-    def apply_map_func(op: cirq.Operation, idx: int) -> List[cirq.Operation]:
+    def apply_map_func(op: cirq.Operation, idx: int) -> list[cirq.Operation]:
         if tags_to_ignore_set.intersection(op.tags):
             return [op]
         if deep and isinstance(op.untagged, circuits.CircuitOperation):
@@ -175,7 +163,7 @@ def _map_operations_impl(
             ).with_tags(*op.tags)
         mapped_ops = [*ops.flatten_to_ops(map_func(op, idx))]
         op_qubits = set(op.qubits)
-        mapped_ops_qubits: Set[cirq.Qid] = set()
+        mapped_ops_qubits: set[cirq.Qid] = set()
         has_overlapping_ops = False
         for mapped_op in mapped_ops:
             if raise_if_add_qubits and not op_qubits.issuperset(mapped_op.qubits):
@@ -196,9 +184,9 @@ def _map_operations_impl(
             ]
         return mapped_ops
 
-    new_moments: List[List[cirq.Operation]] = []
+    new_moments: list[list[cirq.Operation]] = []
     for idx, moment in enumerate(circuit):
-        curr_moments: List[List[cirq.Operation]] = [[]] if wrap_in_circuit_op else []
+        curr_moments: list[list[cirq.Operation]] = [[]] if wrap_in_circuit_op else []
         placement_cache = circuits.circuit._PlacementCache()
         for op in moment:
             mapped_ops = apply_map_func(op, idx)
@@ -307,16 +295,16 @@ class _MergedCircuit:
             of a set to store operations to preserve insertion order.
     """
 
-    qubit_indexes: Dict[cirq.Qid, List[int]] = dataclasses.field(
+    qubit_indexes: dict[cirq.Qid, list[int]] = dataclasses.field(
         default_factory=lambda: defaultdict(lambda: [-1])
     )
-    mkey_indexes: Dict[cirq.MeasurementKey, List[int]] = dataclasses.field(
+    mkey_indexes: dict[cirq.MeasurementKey, list[int]] = dataclasses.field(
         default_factory=lambda: defaultdict(lambda: [-1])
     )
-    ckey_indexes: Dict[cirq.MeasurementKey, List[int]] = dataclasses.field(
+    ckey_indexes: dict[cirq.MeasurementKey, list[int]] = dataclasses.field(
         default_factory=lambda: defaultdict(lambda: [-1])
     )
-    ops_by_index: List[Dict[cirq.Operation, int]] = dataclasses.field(default_factory=list)
+    ops_by_index: list[dict[cirq.Operation, int]] = dataclasses.field(default_factory=list)
 
     def append_empty_moment(self) -> None:
         self.ops_by_index.append({})
@@ -346,8 +334,8 @@ class _MergedCircuit:
             self.ckey_indexes[ckey].remove(moment_index)
 
     def get_mergeable_ops(
-        self, op: cirq.Operation, op_qs: Set[cirq.Qid]
-    ) -> Tuple[int, List[cirq.Operation]]:
+        self, op: cirq.Operation, op_qs: set[cirq.Qid]
+    ) -> tuple[int, list[cirq.Operation]]:
         # Find the index of previous moment which can be merged with `op`.
         idx = max([self.qubit_indexes[q][-1] for q in op_qs], default=-1)
         idx = max([idx] + [self.mkey_indexes[ckey][-1] for ckey in protocols.control_keys(op)])
@@ -368,7 +356,7 @@ class _MergedCircuit:
 
 def merge_operations(
     circuit: CIRCUIT_TYPE,
-    merge_func: Callable[[ops.Operation, ops.Operation], Optional[ops.Operation]],
+    merge_func: Callable[[ops.Operation, ops.Operation], ops.Operation | None],
     *,
     tags_to_ignore: Sequence[Hashable] = (),
     deep: bool = False,
@@ -422,7 +410,7 @@ def merge_operations(
     _circuit_op_tag = "_internal_tag_to_mark_circuit_ops_in_circuit"
     tags_to_ignore_set = set(tags_to_ignore) | {_circuit_op_tag}
 
-    def apply_merge_func(op1: ops.Operation, op2: ops.Operation) -> Optional[ops.Operation]:
+    def apply_merge_func(op1: ops.Operation, op2: ops.Operation) -> ops.Operation | None:
         if not all(tags_to_ignore_set.isdisjoint(op.tags) for op in [op1, op2]):
             return None
         new_op = merge_func(op1, op2)
@@ -435,7 +423,7 @@ def merge_operations(
         return new_op
 
     merged_circuit = _MergedCircuit()
-    for moment_idx, current_moment in enumerate(cast(List['cirq.Moment'], circuit)):
+    for moment_idx, current_moment in enumerate(cast(list['cirq.Moment'], circuit)):
         merged_circuit.append_empty_moment()
         for op in sorted(current_moment.operations, key=lambda op: op.qubits):
             if (
@@ -526,7 +514,7 @@ def merge_operations_to_circuit_op(
         Copy of input circuit with valid connected components wrapped in tagged circuit operations.
     """
 
-    def merge_func(op1: cirq.Operation, op2: cirq.Operation) -> Optional[cirq.Operation]:
+    def merge_func(op1: cirq.Operation, op2: cirq.Operation) -> cirq.Operation | None:
         def get_ops(op: cirq.Operation):
             op_untagged = op.untagged
             return (
@@ -551,7 +539,7 @@ def merge_k_qubit_unitaries_to_circuit_op(
     k: int,
     *,
     tags_to_ignore: Sequence[Hashable] = (),
-    merged_circuit_op_tag: Optional[str] = None,
+    merged_circuit_op_tag: str | None = None,
     deep: bool = False,
 ) -> CIRCUIT_TYPE:
     """Merges connected components of operations, acting on <= k qubits, into circuit operations.
@@ -593,7 +581,7 @@ def merge_k_qubit_unitaries_to_circuit_op(
 
 def merge_moments(
     circuit: CIRCUIT_TYPE,
-    merge_func: Callable[[circuits.Moment, circuits.Moment], Optional[circuits.Moment]],
+    merge_func: Callable[[circuits.Moment, circuits.Moment], circuits.Moment | None],
     *,
     tags_to_ignore: Sequence[Hashable] = (),
     deep: bool = False,
@@ -628,7 +616,7 @@ def merge_moments(
             ),
             tags_to_ignore=tags_to_ignore,
         )
-    merged_moments: List[circuits.Moment] = [circuit[0]]
+    merged_moments: list[circuits.Moment] = [circuit[0]]
     for current_moment in circuit[1:]:
         merged_moment = merge_func(merged_moments[-1], current_moment)
         if merged_moment is None:
@@ -642,7 +630,7 @@ def unroll_circuit_op(
     circuit: CIRCUIT_TYPE,
     *,
     deep: bool = False,
-    tags_to_check: Optional[Sequence[Hashable]] = (MAPPED_CIRCUIT_OP_TAG,),
+    tags_to_check: Sequence[Hashable] | None = (MAPPED_CIRCUIT_OP_TAG,),
 ) -> CIRCUIT_TYPE:
     """Unrolls (tagged) `cirq.CircuitOperation`s while preserving the moment structure.
 
@@ -661,7 +649,7 @@ def unroll_circuit_op(
     """
 
     def map_func(m: circuits.Moment, _: int):
-        to_zip: List[cirq.AbstractCircuit] = []
+        to_zip: list[cirq.AbstractCircuit] = []
         for op in m:
             op_untagged = op.untagged
             if isinstance(op_untagged, circuits.CircuitOperation):
@@ -687,7 +675,7 @@ def unroll_circuit_op_greedy_earliest(
     circuit: CIRCUIT_TYPE,
     *,
     deep: bool = False,
-    tags_to_check: Optional[Sequence[Hashable]] = (MAPPED_CIRCUIT_OP_TAG,),
+    tags_to_check: Sequence[Hashable] | None = (MAPPED_CIRCUIT_OP_TAG,),
 ) -> CIRCUIT_TYPE:
     """Unrolls (tagged) `cirq.CircuitOperation`s by inserting operations using EARLIEST strategy.
 
@@ -734,7 +722,7 @@ def unroll_circuit_op_greedy_frontier(
     circuit: CIRCUIT_TYPE,
     *,
     deep: bool = False,
-    tags_to_check: Optional[Sequence[Hashable]] = (MAPPED_CIRCUIT_OP_TAG,),
+    tags_to_check: Sequence[Hashable] | None = (MAPPED_CIRCUIT_OP_TAG,),
 ) -> CIRCUIT_TYPE:
     """Unrolls (tagged) `cirq.CircuitOperation`s by inserting operations inline at qubit frontier.
 
@@ -753,7 +741,7 @@ def unroll_circuit_op_greedy_frontier(
         Copy of input circuit with (Tagged) CircuitOperation's expanded inline at qubit frontier.
     """
     unrolled_circuit = circuit.unfreeze(copy=True)
-    frontier: Dict[cirq.Qid, int] = defaultdict(lambda: 0)
+    frontier: dict[cirq.Qid, int] = defaultdict(lambda: 0)
     idx = 0
     while idx < len(unrolled_circuit):
         for op in unrolled_circuit[idx].operations:

cirq/transformers/transformer_primitives_test.py

@@ -14,7 +14,7 @@
 
 from __future__ import annotations
 
-from typing import Iterator, List, Optional
+from typing import Iterator
 
 import pytest
 
@@ -503,7 +503,7 @@ def test_map_moments_drop_empty_moments_deep():
     cirq.testing.assert_same_circuits(c_mapped, c_expected)
 
 
-def _merge_z_moments_func(m1: cirq.Moment, m2: cirq.Moment) -> Optional[cirq.Moment]:
+def _merge_z_moments_func(m1: cirq.Moment, m2: cirq.Moment) -> cirq.Moment | None:
     if any(op.gate != cirq.Z for m in [m1, m2] for op in m):
         return None
     return cirq.Moment(
@@ -723,7 +723,7 @@ def test_merge_operations_to_circuit_op_merges_connected_component():
 ''',
     )
 
-    def can_merge(ops1: List[cirq.Operation], ops2: List[cirq.Operation]) -> bool:
+    def can_merge(ops1: list[cirq.Operation], ops2: list[cirq.Operation]) -> bool:
         """Artificial example where a CZ will absorb any merge-able operation."""
         return any(o.gate == cirq.CZ for op_list in [ops1, ops2] for o in op_list)
 

cirq/value/classical_data.py

@@ -16,7 +16,7 @@ from __future__ import annotations
 
 import abc
 import enum
-from typing import Dict, List, Mapping, Optional, Sequence, Tuple, TYPE_CHECKING
+from typing import Mapping, Sequence, TYPE_CHECKING
 
 from typing_extensions import Self
 
@@ -47,17 +47,17 @@ class MeasurementType(enum.IntEnum):
 
 class ClassicalDataStoreReader(abc.ABC):
     @abc.abstractmethod
-    def keys(self) -> Tuple[cirq.MeasurementKey, ...]:
+    def keys(self) -> tuple[cirq.MeasurementKey, ...]:
         """Gets the measurement keys in the order they were stored."""
 
     @property
     @abc.abstractmethod
-    def records(self) -> Mapping[cirq.MeasurementKey, List[Tuple[int, ...]]]:
+    def records(self) -> Mapping[cirq.MeasurementKey, list[tuple[int, ...]]]:
         """Gets the a mapping from measurement key to measurement records."""
 
     @property
     @abc.abstractmethod
-    def channel_records(self) -> Mapping[cirq.MeasurementKey, List[int]]:
+    def channel_records(self) -> Mapping[cirq.MeasurementKey, list[int]]:
         """Gets the a mapping from measurement key to channel measurement records."""
 
     @abc.abstractmethod
@@ -83,7 +83,7 @@ class ClassicalDataStoreReader(abc.ABC):
         """
 
     @abc.abstractmethod
-    def get_digits(self, key: cirq.MeasurementKey, index=-1) -> Tuple[int, ...]:
+    def get_digits(self, key: cirq.MeasurementKey, index=-1) -> tuple[int, ...]:
         """Gets the values of the qubits that were measured into this key.
 
         For example, if the measurement of qubits [q0, q1] produces [0, 1],
@@ -143,10 +143,10 @@ class ClassicalDataDictionaryStore(ClassicalDataStore):
     def __init__(
         self,
         *,
-        _records: Optional[Dict[cirq.MeasurementKey, List[Tuple[int, ...]]]] = None,
-        _measured_qubits: Optional[Dict[cirq.MeasurementKey, List[Tuple[cirq.Qid, ...]]]] = None,
-        _channel_records: Optional[Dict[cirq.MeasurementKey, List[int]]] = None,
-        _measurement_types: Optional[Dict[cirq.MeasurementKey, cirq.MeasurementType]] = None,
+        _records: dict[cirq.MeasurementKey, list[tuple[int, ...]]] | None = None,
+        _measured_qubits: dict[cirq.MeasurementKey, list[tuple[cirq.Qid, ...]]] | None = None,
+        _channel_records: dict[cirq.MeasurementKey, list[int]] | None = None,
+        _measurement_types: dict[cirq.MeasurementKey, cirq.MeasurementType] | None = None,
     ):
         """Initializes a `ClassicalDataDictionaryStore` object."""
         if not _measurement_types:
@@ -165,27 +165,27 @@ class ClassicalDataDictionaryStore(ClassicalDataStore):
             _measured_qubits = {}
         if _channel_records is None:
             _channel_records = {}
-        self._records: Dict[cirq.MeasurementKey, List[Tuple[int, ...]]] = _records
-        self._measured_qubits: Dict[cirq.MeasurementKey, List[Tuple[cirq.Qid, ...]]] = (
+        self._records: dict[cirq.MeasurementKey, list[tuple[int, ...]]] = _records
+        self._measured_qubits: dict[cirq.MeasurementKey, list[tuple[cirq.Qid, ...]]] = (
             _measured_qubits
         )
-        self._channel_records: Dict[cirq.MeasurementKey, List[int]] = _channel_records
-        self._measurement_types: Dict[cirq.MeasurementKey, cirq.MeasurementType] = (
+        self._channel_records: dict[cirq.MeasurementKey, list[int]] = _channel_records
+        self._measurement_types: dict[cirq.MeasurementKey, cirq.MeasurementType] = (
             _measurement_types
         )
 
     @property
-    def records(self) -> Mapping[cirq.MeasurementKey, List[Tuple[int, ...]]]:
+    def records(self) -> Mapping[cirq.MeasurementKey, list[tuple[int, ...]]]:
         """Gets the a mapping from measurement key to measurement records."""
         return self._records
 
     @property
-    def channel_records(self) -> Mapping[cirq.MeasurementKey, List[int]]:
+    def channel_records(self) -> Mapping[cirq.MeasurementKey, list[int]]:
         """Gets the a mapping from measurement key to channel measurement records."""
         return self._channel_records
 
     @property
-    def measured_qubits(self) -> Mapping[cirq.MeasurementKey, List[Tuple[cirq.Qid, ...]]]:
+    def measured_qubits(self) -> Mapping[cirq.MeasurementKey, list[tuple[cirq.Qid, ...]]]:
         """Gets the a mapping from measurement key to the qubits measured."""
         return self._measured_qubits
 
@@ -194,7 +194,7 @@ class ClassicalDataDictionaryStore(ClassicalDataStore):
         """Gets the a mapping from measurement key to the measurement type."""
         return self._measurement_types
 
-    def keys(self) -> Tuple[cirq.MeasurementKey, ...]:
+    def keys(self) -> tuple[cirq.MeasurementKey, ...]:
         return tuple(self._measurement_types.keys())
 
     def record_measurement(
@@ -225,7 +225,7 @@ class ClassicalDataDictionaryStore(ClassicalDataStore):
             raise ValueError(f"Measurement already logged to key {key}")
         self._channel_records[key].append(measurement)
 
-    def get_digits(self, key: cirq.MeasurementKey, index=-1) -> Tuple[int, ...]:
+    def get_digits(self, key: cirq.MeasurementKey, index=-1) -> tuple[int, ...]:
         return (
             self._records[key][index]
             if self._measurement_types[key] == MeasurementType.MEASUREMENT

cirq/value/condition.py

@@ -16,7 +16,7 @@ from __future__ import annotations
 
 import abc
 import dataclasses
-from typing import Any, Dict, FrozenSet, Mapping, Optional, Tuple, TYPE_CHECKING
+from typing import Any, Mapping, TYPE_CHECKING
 
 import attrs
 import sympy
@@ -34,7 +34,7 @@ class Condition(abc.ABC):
 
     @property
     @abc.abstractmethod
-    def keys(self) -> Tuple[cirq.MeasurementKey, ...]:
+    def keys(self) -> tuple[cirq.MeasurementKey, ...]:
         """Gets the control keys."""
 
     @abc.abstractmethod
@@ -50,7 +50,7 @@ class Condition(abc.ABC):
     def qasm(self):
         """Returns the qasm of this condition."""
 
-    def _qasm_(self, args: cirq.QasmArgs, **kwargs) -> Optional[str]:
+    def _qasm_(self, args: cirq.QasmArgs, **kwargs) -> str | None:
         return self.qasm
 
     def _with_measurement_key_mapping_(self, key_map: Mapping[str, str]) -> cirq.Condition:
@@ -59,14 +59,14 @@ class Condition(abc.ABC):
             condition = condition.replace_key(k, mkp.with_measurement_key_mapping(k, key_map))
         return condition
 
-    def _with_key_path_prefix_(self, path: Tuple[str, ...]) -> cirq.Condition:
+    def _with_key_path_prefix_(self, path: tuple[str, ...]) -> cirq.Condition:
         condition = self
         for k in self.keys:
             condition = condition.replace_key(k, mkp.with_key_path_prefix(k, path))
         return condition
 
     def _with_rescoped_keys_(
-        self, path: Tuple[str, ...], bindable_keys: FrozenSet[cirq.MeasurementKey]
+        self, path: tuple[str, ...], bindable_keys: frozenset[cirq.MeasurementKey]
     ) -> cirq.Condition:
         condition = self
         for key in self.keys:
@@ -121,7 +121,7 @@ class KeyCondition(Condition):
     def qasm(self):
         raise ValueError('QASM is defined only for SympyConditions of type key == constant.')
 
-    def _qasm_(self, args: cirq.QasmArgs, **kwargs) -> Optional[str]:
+    def _qasm_(self, args: cirq.QasmArgs, **kwargs) -> str | None:
         args.validate_version('2.0', '3.0')
         key_str = str(self.key)
         if key_str not in args.meas_key_id_map:
@@ -174,7 +174,7 @@ class BitMaskKeyCondition(Condition):
     index: int = -1
     target_value: int = 0
     equal_target: bool = False
-    bitmask: Optional[int] = None
+    bitmask: int | None = None
 
     @property
     def keys(self):
@@ -285,7 +285,7 @@ class SympyCondition(Condition):
         if missing:
             raise ValueError(f'Measurement keys {missing} missing when testing classical control')
 
-        replacements: Dict[str, Any] = {}
+        replacements: dict[str, Any] = {}
         for symbol in self.expr.free_symbols:
             if isinstance(symbol, sympy.Symbol):
                 name = symbol.name

cirq/value/digits.py

@@ -14,7 +14,7 @@
 
 from __future__ import annotations
 
-from typing import Any, Iterable, List, Optional, overload, Union
+from typing import Any, Iterable, overload
 
 
 def big_endian_bits_to_int(bits: Iterable[Any]) -> int:
@@ -48,7 +48,7 @@ def big_endian_bits_to_int(bits: Iterable[Any]) -> int:
     return result
 
 
-def big_endian_int_to_bits(val: int, *, bit_count: int) -> List[int]:
+def big_endian_int_to_bits(val: int, *, bit_count: int) -> list[int]:
     """Returns the big-endian bits of an integer.
 
     Args:
@@ -74,7 +74,7 @@ def big_endian_int_to_bits(val: int, *, bit_count: int) -> List[int]:
     return [(val >> i) & 1 for i in range(bit_count)[::-1]]
 
 
-def big_endian_digits_to_int(digits: Iterable[int], *, base: Union[int, Iterable[int]]) -> int:
+def big_endian_digits_to_int(digits: Iterable[int], *, base: int | Iterable[int]) -> int:
     """Returns the big-endian integer specified by the given digits and base.
 
     Args:
@@ -122,18 +122,18 @@ def big_endian_digits_to_int(digits: Iterable[int], *, base: Union[int, Iterable
 
 # pylint: disable=function-redefined
 @overload
-def big_endian_int_to_digits(val: int, *, digit_count: int, base: int) -> List[int]:
+def big_endian_int_to_digits(val: int, *, digit_count: int, base: int) -> list[int]:
     pass
 
 
 @overload
-def big_endian_int_to_digits(val: int, *, base: Iterable[int]) -> List[int]:
+def big_endian_int_to_digits(val: int, *, base: Iterable[int]) -> list[int]:
     pass
 
 
 def big_endian_int_to_digits(
-    val: int, *, digit_count: Optional[int] = None, base: Union[int, Iterable[int]]
-) -> List[int]:
+    val: int, *, digit_count: int | None = None, base: int | Iterable[int]
+) -> list[int]:
     """Separates an integer into big-endian digits.
 
     Args:

cirq/value/duration.py

@@ -17,7 +17,7 @@
 from __future__ import annotations
 
 import datetime
-from typing import AbstractSet, Any, Dict, List, Optional, Tuple, TYPE_CHECKING, Union
+from typing import AbstractSet, Any, TYPE_CHECKING, TypeAlias, Union
 
 import numpy as np
 import sympy
@@ -45,8 +45,8 @@ document(
 )
 
 
-_NUMERIC_INPUT_TYPE = Union[int, float, sympy.Expr, np.number]
-_NUMERIC_OUTPUT_TYPE = Union[int, float, sympy.Expr]
+_NUMERIC_INPUT_TYPE: TypeAlias = int | float | sympy.Expr | np.number
+_NUMERIC_OUTPUT_TYPE: TypeAlias = int | float | sympy.Expr
 
 
 class Duration:
@@ -82,7 +82,7 @@ class Duration:
             >>> print(cirq.Duration(micros=1.5 * sympy.Symbol('t')))
             (1500.0*t) ns
         """
-        self._time_vals: List[_NUMERIC_INPUT_TYPE] = [0, 0, 0, 0]
+        self._time_vals: list[_NUMERIC_INPUT_TYPE] = [0, 0, 0, 0]
         self._multipliers = [1, 1000, 1000_000, 1000_000_000]
         if value is not None and value != 0:
             if isinstance(value, datetime.timedelta):
@@ -159,7 +159,7 @@ class Duration:
     def __rmul__(self, other) -> Duration:
         return self.__mul__(other)
 
-    def __truediv__(self, other) -> Union[Duration, float]:
+    def __truediv__(self, other) -> Duration | float:
         if isinstance(other, (int, float, sympy.Expr)):
             new_time_vals = [x / other for x in self._time_vals]
             return _duration_from_time_vals(new_time_vals)
@@ -214,7 +214,7 @@ class Duration:
             return hash(datetime.timedelta(microseconds=self.total_picos() / 1000000))
         return hash((Duration, self.total_picos()))
 
-    def _decompose_into_amount_unit_suffix(self) -> Tuple[int, str, str]:
+    def _decompose_into_amount_unit_suffix(self) -> tuple[int, str, str]:
         picos = self.total_picos()
         if (
             isinstance(picos, sympy.Mul)
@@ -261,11 +261,11 @@ class Duration:
         amount, unit, _ = self._decompose_into_amount_unit_suffix()
         return f'cirq.Duration({unit}={proper_repr(amount)})'
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return {'picos': self.total_picos()}
 
 
-def _attempt_duration_like_to_duration(value: Any) -> Optional[Duration]:
+def _attempt_duration_like_to_duration(value: Any) -> Duration | None:
     if isinstance(value, Duration):
         return value
     if isinstance(value, datetime.timedelta):
@@ -276,9 +276,9 @@ def _attempt_duration_like_to_duration(value: Any) -> Optional[Duration]:
 
 
 def _add_time_vals(
-    val1: List[_NUMERIC_INPUT_TYPE], val2: List[_NUMERIC_INPUT_TYPE]
-) -> List[_NUMERIC_INPUT_TYPE]:
-    ret: List[_NUMERIC_INPUT_TYPE] = []
+    val1: list[_NUMERIC_INPUT_TYPE], val2: list[_NUMERIC_INPUT_TYPE]
+) -> list[_NUMERIC_INPUT_TYPE]:
+    ret: list[_NUMERIC_INPUT_TYPE] = []
     for i in range(4):
         if val1[i] and val2[i]:
             ret.append(val1[i] + val2[i])
@@ -287,7 +287,7 @@ def _add_time_vals(
     return ret
 
 
-def _duration_from_time_vals(time_vals: List[_NUMERIC_INPUT_TYPE]):
+def _duration_from_time_vals(time_vals: list[_NUMERIC_INPUT_TYPE]):
     ret = Duration()
     ret._time_vals = time_vals
     return ret