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

cirq/circuits/circuit_operation.py

@@ -23,21 +23,7 @@ from __future__ import annotations
 
 import math
 from functools import cached_property
-from typing import (
-    Any,
-    Callable,
-    cast,
-    Dict,
-    FrozenSet,
-    Iterator,
-    List,
-    Mapping,
-    Optional,
-    Sequence,
-    Tuple,
-    TYPE_CHECKING,
-    Union,
-)
+from typing import Any, Callable, cast, Iterator, Mapping, Sequence, TYPE_CHECKING, TypeAlias
 
 import numpy as np
 import sympy
@@ -50,12 +36,12 @@ if TYPE_CHECKING:
 
 
 INT_CLASSES = (int, np.integer)
-INT_TYPE = Union[int, np.integer]
-IntParam = Union[INT_TYPE, sympy.Expr]
+INT_TYPE: TypeAlias = int | np.integer
+IntParam: TypeAlias = INT_TYPE | sympy.Expr
 REPETITION_ID_SEPARATOR = '-'
 
 
-def default_repetition_ids(repetitions: IntParam) -> Optional[List[str]]:
+def default_repetition_ids(repetitions: IntParam) -> list[str] | None:
     if isinstance(repetitions, INT_CLASSES) and abs(repetitions) != 1:
         abs_repetitions: int = abs(int(repetitions))
         return [str(i) for i in range(abs_repetitions)]
@@ -63,8 +49,8 @@ def default_repetition_ids(repetitions: IntParam) -> Optional[List[str]]:
 
 
 def _full_join_string_lists(
-    list1: Optional[Sequence[str]], list2: Optional[Sequence[str]]
-) -> Optional[Sequence[str]]:
+    list1: Sequence[str] | None, list2: Sequence[str] | None
+) -> Sequence[str] | None:
     if list1 is None and list2 is None:
         return None  # pragma: no cover
     if list1 is None:
@@ -86,14 +72,14 @@ class CircuitOperation(ops.Operation):
         self,
         circuit: cirq.FrozenCircuit,
         repetitions: INT_TYPE = 1,
-        qubit_map: Optional[Dict[cirq.Qid, cirq.Qid]] = None,
-        measurement_key_map: Optional[Dict[str, str]] = None,
-        param_resolver: Optional[study.ParamResolverOrSimilarType] = None,
-        repetition_ids: Optional[Sequence[str]] = None,
-        parent_path: Tuple[str, ...] = (),
-        extern_keys: FrozenSet[cirq.MeasurementKey] = frozenset(),
-        use_repetition_ids: Optional[bool] = None,
-        repeat_until: Optional[cirq.Condition] = None,
+        qubit_map: dict[cirq.Qid, cirq.Qid] | None = None,
+        measurement_key_map: dict[str, str] | None = None,
+        param_resolver: study.ParamResolverOrSimilarType | None = None,
+        repetition_ids: Sequence[str] | None = None,
+        parent_path: tuple[str, ...] = (),
+        extern_keys: frozenset[cirq.MeasurementKey] = frozenset(),
+        use_repetition_ids: bool | None = None,
+        repeat_until: cirq.Condition | None = None,
     ):
         """Initializes a CircuitOperation.
 
@@ -225,7 +211,7 @@ class CircuitOperation(ops.Operation):
         return self._repetitions
 
     @property
-    def repetition_ids(self) -> Optional[Sequence[str]]:
+    def repetition_ids(self) -> Sequence[str] | None:
         return self._repetition_ids
 
     @property
@@ -233,7 +219,7 @@ class CircuitOperation(ops.Operation):
         return self._use_repetition_ids
 
     @property
-    def repeat_until(self) -> Optional[cirq.Condition]:
+    def repeat_until(self) -> cirq.Condition | None:
         return self._repeat_until
 
     @property
@@ -249,7 +235,7 @@ class CircuitOperation(ops.Operation):
         return self._param_resolver
 
     @property
-    def parent_path(self) -> Tuple[str, ...]:
+    def parent_path(self) -> tuple[str, ...]:
         return self._parent_path
 
     def base_operation(self) -> cirq.CircuitOperation:
@@ -296,15 +282,15 @@ class CircuitOperation(ops.Operation):
     # Methods for getting post-mapping properties of the contained circuit.
 
     @property
-    def qubits(self) -> Tuple[cirq.Qid, ...]:
+    def qubits(self) -> tuple[cirq.Qid, ...]:
         """Returns the qubits operated on by this object."""
         ordered_qubits = ops.QubitOrder.DEFAULT.order_for(self.circuit.all_qubits())
         return tuple(self.qubit_map.get(q, q) for q in ordered_qubits)
 
-    def _default_repetition_ids(self) -> Optional[List[str]]:
+    def _default_repetition_ids(self) -> list[str] | None:
         return default_repetition_ids(self.repetitions) if self.use_repetition_ids else None
 
-    def _qid_shape_(self) -> Tuple[int, ...]:
+    def _qid_shape_(self) -> tuple[int, ...]:
         return tuple(q.dimension for q in self.qubits)
 
     def _is_measurement_(self) -> bool:
@@ -322,7 +308,7 @@ class CircuitOperation(ops.Operation):
             raise ValueError('Cannot unroll circuit due to nondeterministic repetitions')
 
     @cached_property
-    def _measurement_key_objs(self) -> FrozenSet[cirq.MeasurementKey]:
+    def _measurement_key_objs(self) -> frozenset[cirq.MeasurementKey]:
         circuit_keys = protocols.measurement_key_objs(self.circuit)
         if circuit_keys and self.use_repetition_ids:
             self._ensure_deterministic_loop_count()
@@ -340,14 +326,14 @@ class CircuitOperation(ops.Operation):
             for key in circuit_keys
         )
 
-    def _measurement_key_objs_(self) -> FrozenSet[cirq.MeasurementKey]:
+    def _measurement_key_objs_(self) -> frozenset[cirq.MeasurementKey]:
         return self._measurement_key_objs
 
-    def _measurement_key_names_(self) -> FrozenSet[str]:
+    def _measurement_key_names_(self) -> frozenset[str]:
         return frozenset(str(key) for key in self._measurement_key_objs_())
 
     @cached_property
-    def _control_keys(self) -> FrozenSet[cirq.MeasurementKey]:
+    def _control_keys(self) -> frozenset[cirq.MeasurementKey]:
         keys = (
             frozenset()
             if not protocols.control_keys(self.circuit)
@@ -358,13 +344,13 @@ class CircuitOperation(ops.Operation):
             keys |= frozenset(mapped_repeat_until.keys) - self._measurement_key_objs_()
         return keys
 
-    def _control_keys_(self) -> FrozenSet[cirq.MeasurementKey]:
+    def _control_keys_(self) -> frozenset[cirq.MeasurementKey]:
         return self._control_keys
 
     def _is_parameterized_(self) -> bool:
         return any(self._parameter_names_generator())
 
-    def _parameter_names_(self) -> FrozenSet[str]:
+    def _parameter_names_(self) -> frozenset[str]:
         return frozenset(self._parameter_names_generator())
 
     def _parameter_names_generator(self) -> Iterator[str]:
@@ -385,7 +371,7 @@ class CircuitOperation(ops.Operation):
             circuit = protocols.resolve_parameters(circuit, self.param_resolver, recursive=False)
         return circuit.unfreeze(copy=False)
 
-    def _mapped_single_loop(self, repetition_id: Optional[str] = None) -> cirq.Circuit:
+    def _mapped_single_loop(self, repetition_id: str | None = None) -> cirq.Circuit:
         circuit = self._mapped_any_loop
         if repetition_id:
             circuit = protocols.with_rescoped_keys(circuit, (repetition_id,))
@@ -394,7 +380,7 @@ class CircuitOperation(ops.Operation):
         )
 
     @cached_property
-    def _mapped_repeat_until(self) -> Optional[cirq.Condition]:
+    def _mapped_repeat_until(self) -> cirq.Condition | None:
         """Applies measurement_key_map, param_resolver, and current scope to repeat_until."""
         repeat_until = self.repeat_until
         if not repeat_until:
@@ -536,7 +522,7 @@ class CircuitOperation(ops.Operation):
     def __hash__(self) -> int:
         return self._hash
 
-    def __getstate__(self) -> Dict[str, Any]:
+    def __getstate__(self) -> dict[str, Any]:
         # clear cached hash value when pickling, see #6674
         state = self.__dict__
         # cached_property stores value in the property-named attribute
@@ -593,9 +579,9 @@ class CircuitOperation(ops.Operation):
 
     def repeat(
         self,
-        repetitions: Optional[IntParam] = None,
-        repetition_ids: Optional[Sequence[str]] = None,
-        use_repetition_ids: Optional[bool] = None,
+        repetitions: IntParam | None = None,
+        repetition_ids: Sequence[str] | None = None,
+        use_repetition_ids: bool | None = None,
     ) -> CircuitOperation:
         """Returns a copy of this operation repeated 'repetitions' times.
          Each repetition instance will be identified by a single repetition_id.
@@ -662,14 +648,14 @@ class CircuitOperation(ops.Operation):
     def __pow__(self, power: IntParam) -> cirq.CircuitOperation:
         return self.repeat(power)
 
-    def _with_key_path_(self, path: Tuple[str, ...]):
+    def _with_key_path_(self, path: tuple[str, ...]):
         return self.replace(parent_path=path)
 
-    def _with_key_path_prefix_(self, prefix: Tuple[str, ...]):
+    def _with_key_path_prefix_(self, prefix: tuple[str, ...]):
         return self.replace(parent_path=prefix + self.parent_path)
 
     def _with_rescoped_keys_(
-        self, path: Tuple[str, ...], bindable_keys: FrozenSet[cirq.MeasurementKey]
+        self, path: tuple[str, ...], bindable_keys: frozenset[cirq.MeasurementKey]
     ):
         # The following line prevents binding to measurement keys in previous repeated subcircuits
         # "just because their repetition ids matched". If we eventually decide to change that
@@ -681,7 +667,7 @@ class CircuitOperation(ops.Operation):
         path += self.parent_path
         return self.replace(parent_path=path, extern_keys=bindable_keys)
 
-    def with_key_path(self, path: Tuple[str, ...]):
+    def with_key_path(self, path: tuple[str, ...]):
         """Alias for `cirq.with_key_path(self, path)`.
 
         Args:
@@ -693,7 +679,7 @@ class CircuitOperation(ops.Operation):
         """
         return self._with_key_path_(path)
 
-    def with_repetition_ids(self, repetition_ids: List[str]) -> cirq.CircuitOperation:
+    def with_repetition_ids(self, repetition_ids: list[str]) -> cirq.CircuitOperation:
         """Returns a copy of this `CircuitOperation` with the given repetition IDs.
 
         Args:
@@ -706,7 +692,7 @@ class CircuitOperation(ops.Operation):
         return self.replace(repetition_ids=repetition_ids)
 
     def with_qubit_mapping(
-        self, qubit_map: Union[Mapping[cirq.Qid, cirq.Qid], Callable[[cirq.Qid], cirq.Qid]]
+        self, qubit_map: Mapping[cirq.Qid, cirq.Qid] | Callable[[cirq.Qid], cirq.Qid]
     ) -> cirq.CircuitOperation:
         """Returns a copy of this operation with an updated qubit mapping.
 

cirq/circuits/circuit_test.py

@@ -19,7 +19,7 @@ import os
 import time
 from collections import defaultdict
 from random import randint, random, randrange, sample
-from typing import Iterator, Optional, Tuple
+from typing import Iterator
 
 import numpy as np
 import pytest
@@ -894,7 +894,7 @@ def test_insert_at_frontier():
 
         def optimization_at(
             self, circuit: cirq.Circuit, index: int, op: cirq.Operation
-        ) -> Optional[cirq.PointOptimizationSummary]:
+        ) -> cirq.PointOptimizationSummary | None:
             new_ops = self.replacer(op)
             return cirq.PointOptimizationSummary(
                 clear_span=1, clear_qubits=op.qubits, new_operations=new_ops
@@ -2122,7 +2122,7 @@ M('msg')─M──────M
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
 def test_to_text_diagram_many_qubits_gate_but_multiple_wire_symbols(circuit_cls):
     class BadGate(cirq.testing.ThreeQubitGate):
-        def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> Tuple[str, str]:
+        def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> tuple[str, str]:
             return 'a', 'a'
 
     q1 = cirq.NamedQubit('(0, 0)')
@@ -2724,7 +2724,7 @@ def test_expanding_gate_symbols(circuit_cls):
         def num_qubits(self) -> int:
             return self._num_qubits
 
-        def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> Tuple[str, ...]:
+        def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> tuple[str, ...]:
             assert args.known_qubit_count is not None
             return ('@',) + ('Z',) * (args.known_qubit_count - 1)
 

cirq/circuits/frozen_circuit.py

@@ -18,17 +18,7 @@ from __future__ import annotations
 
 from functools import cached_property
 from types import NotImplementedType
-from typing import (
-    AbstractSet,
-    FrozenSet,
-    Hashable,
-    Iterable,
-    Iterator,
-    Sequence,
-    Tuple,
-    TYPE_CHECKING,
-    Union,
-)
+from typing import AbstractSet, Hashable, Iterable, Iterator, Sequence, TYPE_CHECKING
 
 from cirq import _compat, protocols
 from cirq.circuits import AbstractCircuit, Alignment, Circuit
@@ -91,7 +81,7 @@ class FrozenCircuit(AbstractCircuit, protocols.SerializableByKey):
         return Circuit._from_moments(self._moments)
 
     @property
-    def tags(self) -> Tuple[Hashable, ...]:
+    def tags(self) -> tuple[Hashable, ...]:
         """Returns a tuple of the Circuit's tags."""
         return self._tags
 
@@ -134,7 +124,7 @@ class FrozenCircuit(AbstractCircuit, protocols.SerializableByKey):
         return len(self.all_qubits())
 
     @_compat.cached_method
-    def _qid_shape_(self) -> Tuple[int, ...]:
+    def _qid_shape_(self) -> tuple[int, ...]:
         return super()._qid_shape_()
 
     @_compat.cached_method
@@ -142,7 +132,7 @@ class FrozenCircuit(AbstractCircuit, protocols.SerializableByKey):
         return super()._has_unitary_()
 
     @_compat.cached_method
-    def _unitary_(self) -> Union[np.ndarray, NotImplementedType]:
+    def _unitary_(self) -> np.ndarray | NotImplementedType:
         return super()._unitary_()
 
     @_compat.cached_method
@@ -150,11 +140,11 @@ class FrozenCircuit(AbstractCircuit, protocols.SerializableByKey):
         return protocols.is_measurement(self.unfreeze())
 
     @_compat.cached_method
-    def all_qubits(self) -> FrozenSet[cirq.Qid]:
+    def all_qubits(self) -> frozenset[cirq.Qid]:
         return super().all_qubits()
 
     @cached_property
-    def _all_operations(self) -> Tuple[cirq.Operation, ...]:
+    def _all_operations(self) -> tuple[cirq.Operation, ...]:
         return tuple(super().all_operations())
 
     def all_operations(self) -> Iterator[cirq.Operation]:
@@ -164,14 +154,14 @@ class FrozenCircuit(AbstractCircuit, protocols.SerializableByKey):
         return self._is_measurement_()
 
     @_compat.cached_method
-    def all_measurement_key_objs(self) -> FrozenSet[cirq.MeasurementKey]:
+    def all_measurement_key_objs(self) -> frozenset[cirq.MeasurementKey]:
         return super().all_measurement_key_objs()
 
-    def _measurement_key_objs_(self) -> FrozenSet[cirq.MeasurementKey]:
+    def _measurement_key_objs_(self) -> frozenset[cirq.MeasurementKey]:
         return self.all_measurement_key_objs()
 
     @_compat.cached_method
-    def _control_keys_(self) -> FrozenSet[cirq.MeasurementKey]:
+    def _control_keys_(self) -> frozenset[cirq.MeasurementKey]:
         return super()._control_keys_()
 
     @_compat.cached_method
@@ -179,7 +169,7 @@ class FrozenCircuit(AbstractCircuit, protocols.SerializableByKey):
         return super().are_all_measurements_terminal()
 
     @_compat.cached_method
-    def all_measurement_key_names(self) -> FrozenSet[str]:
+    def all_measurement_key_names(self) -> frozenset[str]:
         return frozenset(str(key) for key in self.all_measurement_key_objs())
 
     @_compat.cached_method
@@ -202,7 +192,7 @@ class FrozenCircuit(AbstractCircuit, protocols.SerializableByKey):
         ]
         return resolved_circuit.with_tags(*resolved_tags)
 
-    def _measurement_key_names_(self) -> FrozenSet[str]:
+    def _measurement_key_names_(self) -> frozenset[str]:
         return self.all_measurement_key_names()
 
     def __add__(self, other) -> cirq.FrozenCircuit:
@@ -242,14 +232,14 @@ class FrozenCircuit(AbstractCircuit, protocols.SerializableByKey):
         return cls(moments, strategy=InsertStrategy.EARLIEST, tags=tags)
 
     def concat_ragged(
-        *circuits: cirq.AbstractCircuit, align: Union[cirq.Alignment, str] = Alignment.LEFT
+        *circuits: cirq.AbstractCircuit, align: cirq.Alignment | str = Alignment.LEFT
     ) -> cirq.FrozenCircuit:
         return AbstractCircuit.concat_ragged(*circuits, align=align).freeze()
 
     concat_ragged.__doc__ = AbstractCircuit.concat_ragged.__doc__
 
     def zip(
-        *circuits: cirq.AbstractCircuit, align: Union[cirq.Alignment, str] = Alignment.LEFT
+        *circuits: cirq.AbstractCircuit, align: cirq.Alignment | str = Alignment.LEFT
     ) -> cirq.FrozenCircuit:
         return AbstractCircuit.zip(*circuits, align=align).freeze()
 

cirq/circuits/moment.py

@@ -24,18 +24,12 @@ from typing import (
     Any,
     Callable,
     cast,
-    Dict,
-    FrozenSet,
     Iterable,
     Iterator,
-    List,
     Mapping,
-    Optional,
     overload,
     Sequence,
-    Tuple,
     TYPE_CHECKING,
-    Union,
 )
 
 import numpy as np
@@ -57,7 +51,7 @@ text_diagram_drawer = LazyLoader(
 )
 
 
-def _default_breakdown(qid: cirq.Qid) -> Tuple[Any, Any]:
+def _default_breakdown(qid: cirq.Qid) -> tuple[Any, Any]:
     # Attempt to convert into a position on the complex plane.
     try:
         plane_pos = complex(qid)  # type: ignore
@@ -102,12 +96,12 @@ class Moment:
         self._operations = (
             tuple(op_tree.flatten_to_ops(contents))
             if _flatten_contents
-            else cast(Tuple['cirq.Operation'], contents)
+            else cast(tuple['cirq.Operation'], contents)
         )
-        self._sorted_operations: Optional[Tuple[cirq.Operation, ...]] = None
+        self._sorted_operations: tuple[cirq.Operation, ...] | None = None
 
         # An internal dictionary to support efficient operation access by qubit.
-        self._qubit_to_op: Dict[cirq.Qid, cirq.Operation] = {}
+        self._qubit_to_op: dict[cirq.Qid, cirq.Operation] = {}
         for op in self.operations:
             for q in op.qubits:
                 # Check that operations don't overlap.
@@ -115,8 +109,8 @@ class Moment:
                     raise ValueError(f'Overlapping operations: {self.operations}')
                 self._qubit_to_op[q] = op
 
-        self._measurement_key_objs: Optional[FrozenSet[cirq.MeasurementKey]] = None
-        self._control_keys: Optional[FrozenSet[cirq.MeasurementKey]] = None
+        self._measurement_key_objs: frozenset[cirq.MeasurementKey] | None = None
+        self._control_keys: frozenset[cirq.MeasurementKey] | None = None
 
     @classmethod
     def from_ops(cls, *ops: cirq.Operation) -> cirq.Moment:
@@ -133,11 +127,11 @@ class Moment:
         return cls(*ops, _flatten_contents=False)
 
     @property
-    def operations(self) -> Tuple[cirq.Operation, ...]:
+    def operations(self) -> tuple[cirq.Operation, ...]:
         return self._operations
 
     @cached_property
-    def qubits(self) -> FrozenSet[cirq.Qid]:
+    def qubits(self) -> frozenset[cirq.Qid]:
         return frozenset(self._qubit_to_op)
 
     def operates_on_single_qubit(self, qubit: cirq.Qid) -> bool:
@@ -160,7 +154,7 @@ class Moment:
         """
         return not self._qubit_to_op.keys().isdisjoint(qubits)
 
-    def operation_at(self, qubit: raw_types.Qid) -> Optional[cirq.Operation]:
+    def operation_at(self, qubit: raw_types.Qid) -> cirq.Operation | None:
         """Returns the operation on a certain qubit for the moment.
 
         Args:
@@ -267,7 +261,7 @@ class Moment:
 
     def _resolve_parameters_(self, resolver: cirq.ParamResolver, recursive: bool) -> cirq.Moment:
         changed = False
-        resolved_ops: List[cirq.Operation] = []
+        resolved_ops: list[cirq.Operation] = []
         for op in self:
             resolved_op = protocols.resolve_parameters(op, resolver, recursive)
             changed = (
@@ -291,35 +285,35 @@ class Moment:
         )
 
     @_compat.cached_method()
-    def _measurement_key_names_(self) -> FrozenSet[str]:
+    def _measurement_key_names_(self) -> frozenset[str]:
         return frozenset(str(key) for key in self._measurement_key_objs_())
 
-    def _measurement_key_objs_(self) -> FrozenSet[cirq.MeasurementKey]:
+    def _measurement_key_objs_(self) -> frozenset[cirq.MeasurementKey]:
         if self._measurement_key_objs is None:
             self._measurement_key_objs = frozenset(
                 key for op in self.operations for key in protocols.measurement_key_objs(op)
             )
         return self._measurement_key_objs
 
-    def _control_keys_(self) -> FrozenSet[cirq.MeasurementKey]:
+    def _control_keys_(self) -> frozenset[cirq.MeasurementKey]:
         if self._control_keys is None:
             self._control_keys = frozenset(
                 k for op in self.operations for k in protocols.control_keys(op)
             )
         return self._control_keys
 
-    def _sorted_operations_(self) -> Tuple[cirq.Operation, ...]:
+    def _sorted_operations_(self) -> tuple[cirq.Operation, ...]:
         if self._sorted_operations is None:
             self._sorted_operations = tuple(sorted(self._operations, key=lambda op: op.qubits))
         return self._sorted_operations
 
-    def _with_key_path_(self, path: Tuple[str, ...]):
+    def _with_key_path_(self, path: tuple[str, ...]):
         return Moment(
             protocols.with_key_path(op, path) if protocols.is_measurement(op) else op
             for op in self.operations
         )
 
-    def _with_key_path_prefix_(self, prefix: Tuple[str, ...]):
+    def _with_key_path_prefix_(self, prefix: tuple[str, ...]):
         return Moment(
             (
                 protocols.with_key_path_prefix(op, prefix)
@@ -330,7 +324,7 @@ class Moment:
         )
 
     def _with_rescoped_keys_(
-        self, path: Tuple[str, ...], bindable_keys: FrozenSet[cirq.MeasurementKey]
+        self, path: tuple[str, ...], bindable_keys: frozenset[cirq.MeasurementKey]
     ):
         return Moment(
             protocols.with_rescoped_keys(op, path, bindable_keys) for op in self.operations
@@ -364,7 +358,7 @@ class Moment:
     def __hash__(self):
         return hash((Moment, self._sorted_operations_()))
 
-    def __getstate__(self) -> Dict[str, Any]:
+    def __getstate__(self) -> dict[str, Any]:
         # clear cached hash value when pickling, see #6674
         state = self.__dict__
         hash_attr = _compat._method_cache_name(self.__hash__)
@@ -407,7 +401,7 @@ class Moment:
         return self._operations
 
     def transform_qubits(
-        self, qubit_map: Union[Dict[cirq.Qid, cirq.Qid], Callable[[cirq.Qid], cirq.Qid]]
+        self, qubit_map: dict[cirq.Qid, cirq.Qid] | Callable[[cirq.Qid], cirq.Qid]
     ) -> Self:
         """Returns the same moment, but with different qubits.
 
@@ -516,7 +510,7 @@ class Moment:
             return NotImplemented
         return qis.kraus_to_superoperator(self._kraus_())
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ['operations'])
 
     @classmethod
@@ -569,10 +563,10 @@ class Moment:
     def to_text_diagram(
         self: cirq.Moment,
         *,
-        xy_breakdown_func: Callable[[cirq.Qid], Tuple[Any, Any]] = _default_breakdown,
+        xy_breakdown_func: Callable[[cirq.Qid], tuple[Any, Any]] = _default_breakdown,
         extra_qubits: Iterable[cirq.Qid] = (),
         use_unicode_characters: bool = True,
-        precision: Optional[int] = None,
+        precision: int | None = None,
         include_tags: bool = True,
     ) -> str:
         """Create a text diagram for the moment.
@@ -657,7 +651,7 @@ class Moment:
 
         return diagram.render()
 
-    def _commutes_(self, other: Any, *, atol: float = 1e-8) -> Union[bool, NotImplementedType]:
+    def _commutes_(self, other: Any, *, atol: float = 1e-8) -> bool | NotImplementedType:
         """Determines whether Moment commutes with the other Moment or Operation.
 
         Args:

cirq/circuits/optimization_pass.py

@@ -18,7 +18,7 @@ from __future__ import annotations
 
 import abc
 from collections import defaultdict
-from typing import Callable, cast, Dict, Iterable, Optional, Sequence, Tuple, TYPE_CHECKING
+from typing import Callable, cast, Iterable, Sequence, TYPE_CHECKING
 
 from cirq import ops
 
@@ -106,7 +106,7 @@ class PointOptimizer:
     @abc.abstractmethod
     def optimization_at(
         self, circuit: cirq.Circuit, index: int, op: cirq.Operation
-    ) -> Optional[cirq.PointOptimizationSummary]:
+    ) -> cirq.PointOptimizationSummary | None:
         """Describes how to change operations near the given location.
 
         For example, this method could realize that the given operation is an
@@ -127,7 +127,7 @@ class PointOptimizer:
         """
 
     def optimize_circuit(self, circuit: cirq.Circuit):
-        frontier: Dict[cirq.Qid, int] = defaultdict(lambda: 0)
+        frontier: dict[cirq.Qid, int] = defaultdict(lambda: 0)
         i = 0
         while i < len(circuit):  # Note: circuit may mutate as we go.
             for op in circuit[i].operations:
@@ -150,7 +150,7 @@ class PointOptimizer:
                 circuit.clear_operations_touching(
                     opt.clear_qubits, [e for e in range(i, i + opt.clear_span)]
                 )
-                new_operations = self.post_clean_up(cast(Tuple[ops.Operation], opt.new_operations))
+                new_operations = self.post_clean_up(cast(tuple[ops.Operation], opt.new_operations))
 
                 flat_new_operations = tuple(ops.flatten_to_ops(new_operations))
 

cirq/circuits/optimization_pass_test.py

@@ -14,8 +14,6 @@
 
 from __future__ import annotations
 
-from typing import List, Optional, Set
-
 import pytest
 
 import cirq
@@ -64,7 +62,7 @@ class ReplaceWithXGates(PointOptimizer):
 
     def optimization_at(
         self, circuit: cirq.Circuit, index: int, op: cirq.Operation
-    ) -> Optional[cirq.PointOptimizationSummary]:
+    ) -> cirq.PointOptimizationSummary | None:
         end = index + 1
         new_ops = [cirq.X(q) for q in op.qubits]
         done = False
@@ -72,8 +70,8 @@ class ReplaceWithXGates(PointOptimizer):
             n = circuit.next_moment_operating_on(op.qubits, end)
             if n is None:
                 break
-            next_ops: Set[Optional[Operation]] = {circuit.operation_at(q, n) for q in op.qubits}
-            next_ops_list: List[Operation] = [e for e in next_ops if e]
+            next_ops: set[Operation | None] = {circuit.operation_at(q, n) for q in op.qubits}
+            next_ops_list: list[Operation] = [e for e in next_ops if e]
             next_ops_sorted = sorted(next_ops_list, key=lambda e: str(e.qubits))
             for next_op in next_ops_sorted:
                 if next_op:
@@ -158,7 +156,7 @@ def test_point_optimizer_raises_on_gates_changing_qubits() -> None:
 
         def optimization_at(
             self, circuit: cirq.Circuit, index: int, op: cirq.Operation
-        ) -> Optional[cirq.PointOptimizationSummary]:
+        ) -> cirq.PointOptimizationSummary | None:
             new_op = op
             if len(op.qubits) == 1 and isinstance(op, cirq.GateOperation):
                 new_op = op.gate(cirq.LineQubit(42))