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

cirq/transformers/dynamical_decoupling_test.py

@@ -14,7 +14,7 @@
 
 from __future__ import annotations
 
-from typing import Sequence, Tuple, Union
+from typing import Sequence
 
 import numpy as np
 import pytest
@@ -34,8 +34,8 @@ def assert_sim_eq(circuit1: cirq.AbstractCircuit, circuit2: cirq.AbstractCircuit
 
 def assert_dd(
     input_circuit: cirq.AbstractCircuit,
-    expected_circuit: Union[str, cirq.AbstractCircuit],
-    schema: Union[str, Tuple[cirq.Gate, ...]] = 'DEFAULT',
+    expected_circuit: str | cirq.AbstractCircuit,
+    schema: str | tuple[cirq.Gate, ...] = 'DEFAULT',
     single_qubit_gate_moments_only: bool = True,
 ):
     transformed_circuit = add_dynamical_decoupling(
@@ -254,7 +254,7 @@ def test_pull_through_h_gate_case2(single_qubit_gate_moments_only: bool):
         ),
     ],
 )
-def test_invalid_dd_schema(schema: Union[str, Tuple[cirq.Gate, ...]], error_msg_regex):
+def test_invalid_dd_schema(schema: str | tuple[cirq.Gate, ...], error_msg_regex):
     a = cirq.NamedQubit('a')
     input_circuit = cirq.Circuit(cirq.H(a))
     with pytest.raises(ValueError, match=error_msg_regex):

cirq/transformers/eject_phased_paulis.py

@@ -16,7 +16,7 @@
 
 from __future__ import annotations
 
-from typing import cast, Dict, Iterable, Iterator, Optional, Tuple, TYPE_CHECKING, Union
+from typing import cast, Iterable, Iterator, TYPE_CHECKING
 
 import numpy as np
 import sympy
@@ -33,7 +33,7 @@ if TYPE_CHECKING:
 def eject_phased_paulis(
     circuit: cirq.AbstractCircuit,
     *,
-    context: Optional[cirq.TransformerContext] = None,
+    context: cirq.TransformerContext | None = None,
     atol: float = 1e-8,
     eject_parameterized: bool = False,
 ) -> cirq.Circuit:
@@ -59,7 +59,7 @@ def eject_phased_paulis(
     Returns:
           Copy of the transformed input circuit.
     """
-    held_w_phases: Dict[ops.Qid, value.TParamVal] = {}
+    held_w_phases: dict[ops.Qid, value.TParamVal] = {}
     tags_to_ignore = set(context.tags_to_ignore) if context else set()
 
     def map_func(op: cirq.Operation, _: int) -> cirq.OP_TREE:
@@ -108,7 +108,7 @@ def eject_phased_paulis(
 
 
 def _absorb_z_into_w(
-    op: ops.Operation, held_w_phases: Dict[ops.Qid, value.TParamVal]
+    op: ops.Operation, held_w_phases: dict[ops.Qid, value.TParamVal]
 ) -> cirq.OP_TREE:
     """Absorbs a Z^t gate into a W(a) flip.
 
@@ -129,7 +129,7 @@ def _absorb_z_into_w(
 
 
 def _dump_held(
-    qubits: Iterable[ops.Qid], held_w_phases: Dict[ops.Qid, value.TParamVal], atol: float
+    qubits: Iterable[ops.Qid], held_w_phases: dict[ops.Qid, value.TParamVal], atol: float
 ) -> Iterator[cirq.OP_TREE]:
     # Note: sorting is to avoid non-determinism in the insertion order.
     for q in sorted(qubits):
@@ -141,7 +141,7 @@ def _dump_held(
 
 
 def _dump_into_measurement(
-    op: ops.Operation, held_w_phases: Dict[ops.Qid, value.TParamVal]
+    op: ops.Operation, held_w_phases: dict[ops.Qid, value.TParamVal]
 ) -> cirq.OP_TREE:
     measurement = cast(ops.MeasurementGate, cast(ops.GateOperation, op).gate)
     new_measurement = measurement.with_bits_flipped(
@@ -153,7 +153,7 @@ def _dump_into_measurement(
 
 
 def _potential_cross_whole_w(
-    op: ops.Operation, atol: float, held_w_phases: Dict[ops.Qid, value.TParamVal]
+    op: ops.Operation, atol: float, held_w_phases: dict[ops.Qid, value.TParamVal]
 ) -> cirq.OP_TREE:
     """Grabs or cancels a held W gate against an existing W gate.
 
@@ -167,7 +167,7 @@ def _potential_cross_whole_w(
         ≡ ───Z^2(b-a)───
     """
     _, phase_exponent = cast(
-        Tuple[value.TParamVal, value.TParamVal], _try_get_known_phased_pauli(op)
+        tuple[value.TParamVal, value.TParamVal], _try_get_known_phased_pauli(op)
     )
     q = op.qubits[0]
     a = held_w_phases.get(q, None)
@@ -186,7 +186,7 @@ def _potential_cross_whole_w(
 
 
 def _potential_cross_partial_w(
-    op: ops.Operation, held_w_phases: Dict[ops.Qid, value.TParamVal], atol: float
+    op: ops.Operation, held_w_phases: dict[ops.Qid, value.TParamVal], atol: float
 ) -> cirq.OP_TREE:
     """Cross the held W over a partial W gate.
 
@@ -204,7 +204,7 @@ def _potential_cross_partial_w(
     if a is None:
         return op
     exponent, phase_exponent = cast(
-        Tuple[value.TParamVal, value.TParamVal], _try_get_known_phased_pauli(op)
+        tuple[value.TParamVal, value.TParamVal], _try_get_known_phased_pauli(op)
     )
     gate = _phased_x_or_pauli_gate(
         exponent=exponent, phase_exponent=2 * a - phase_exponent, atol=atol
@@ -252,7 +252,7 @@ def _single_cross_over_cz(op: ops.Operation, qubit_with_w: cirq.Qid) -> cirq.OP_
 
 
 def _double_cross_over_cz(
-    op: ops.Operation, held_w_phases: Dict[ops.Qid, value.TParamVal]
+    op: ops.Operation, held_w_phases: dict[ops.Qid, value.TParamVal]
 ) -> cirq.OP_TREE:
     """Crosses two W flips over a partial CZ.
 
@@ -296,7 +296,7 @@ def _double_cross_over_cz(
 
 def _try_get_known_cz_half_turns(
     op: ops.Operation, no_symbolic: bool = False
-) -> Optional[value.TParamVal]:
+) -> value.TParamVal | None:
     if not isinstance(op.gate, ops.CZPowGate):
         return None
     h = op.gate.exponent
@@ -307,7 +307,7 @@ def _try_get_known_cz_half_turns(
 
 def _try_get_known_phased_pauli(
     op: ops.Operation, no_symbolic: bool = False
-) -> Optional[Tuple[value.TParamVal, value.TParamVal]]:
+) -> tuple[value.TParamVal, value.TParamVal] | None:
     if no_symbolic and protocols.is_parameterized(op):
         return None
     gate = op.gate
@@ -335,7 +335,7 @@ def _try_get_known_phased_pauli(
 
 def _try_get_known_z_half_turns(
     op: ops.Operation, no_symbolic: bool = False
-) -> Optional[value.TParamVal]:
+) -> value.TParamVal | None:
     g = op.gate
     if (
         isinstance(g, ops.PhasedXZGate)
@@ -356,8 +356,8 @@ def _try_get_known_z_half_turns(
 
 
 def _phased_x_or_pauli_gate(
-    exponent: Union[float, sympy.Expr], phase_exponent: Union[float, sympy.Expr], atol: float
-) -> Union[cirq.PhasedXPowGate, cirq.XPowGate, cirq.YPowGate]:
+    exponent: float | sympy.Expr, phase_exponent: float | sympy.Expr, atol: float
+) -> cirq.PhasedXPowGate | cirq.XPowGate | cirq.YPowGate:
     """Return PhasedXPowGate or X or Y gate if equivalent within atol in z-axis turns."""
     if not isinstance(phase_exponent, sympy.Expr) or phase_exponent.is_constant():
         half_turns = value.canonicalize_half_turns(float(phase_exponent))

cirq/transformers/eject_z.py

@@ -17,7 +17,7 @@
 from __future__ import annotations
 
 from collections import defaultdict
-from typing import Dict, Iterable, Iterator, Optional, Tuple, TYPE_CHECKING
+from typing import Iterable, Iterator, TYPE_CHECKING
 
 import numpy as np
 
@@ -50,7 +50,7 @@ def _is_swaplike(gate: cirq.Gate):
 def eject_z(
     circuit: cirq.AbstractCircuit,
     *,
-    context: Optional[cirq.TransformerContext] = None,
+    context: cirq.TransformerContext | None = None,
     atol: float = 0.0,
     eject_parameterized: bool = False,
 ) -> cirq.Circuit:
@@ -72,12 +72,10 @@ def eject_z(
         Copy of the transformed input circuit.
     """
     # Tracks qubit phases (in half turns; multiply by pi to get radians).
-    qubit_phase: Dict[ops.Qid, float] = defaultdict(lambda: 0)
+    qubit_phase: dict[ops.Qid, float] = defaultdict(lambda: 0)
     tags_to_ignore = set(context.tags_to_ignore) if context else set()
-    phased_xz_replacements: Dict[Tuple[int, ops.Operation], ops.PhasedXZGate] = {}
-    last_phased_xz_op: Dict[ops.Qid, Optional[Tuple[int, ops.Operation]]] = defaultdict(
-        lambda: None
-    )
+    phased_xz_replacements: dict[tuple[int, ops.Operation], ops.PhasedXZGate] = {}
+    last_phased_xz_op: dict[ops.Qid, tuple[int, ops.Operation] | None] = defaultdict(lambda: None)
 
     def dump_tracked_phase(qubits: Iterable[ops.Qid]) -> Iterator[cirq.OP_TREE]:
         """Zeroes qubit_phase entries by emitting Z gates."""

cirq/transformers/gauge_compiling/gauge_compiling.py

@@ -21,7 +21,7 @@ import functools
 import itertools
 from dataclasses import dataclass
 from numbers import Real
-from typing import Callable, Dict, List, Optional, Sequence, Tuple, TYPE_CHECKING, Union
+from typing import Callable, Sequence, TYPE_CHECKING
 
 import numpy as np
 import sympy
@@ -70,16 +70,16 @@ class ConstantGauge(Gauge):
     """A gauge that replaces a two qubit gate with a constant gauge."""
 
     two_qubit_gate: ops.Gate
-    pre_q0: Tuple[ops.Gate, ...] = field(
+    pre_q0: tuple[ops.Gate, ...] = field(
         default=(), converter=lambda g: (g,) if isinstance(g, ops.Gate) else tuple(g)
     )
-    pre_q1: Tuple[ops.Gate, ...] = field(
+    pre_q1: tuple[ops.Gate, ...] = field(
         default=(), converter=lambda g: (g,) if isinstance(g, ops.Gate) else tuple(g)
     )
-    post_q0: Tuple[ops.Gate, ...] = field(
+    post_q0: tuple[ops.Gate, ...] = field(
         default=(), converter=lambda g: (g,) if isinstance(g, ops.Gate) else tuple(g)
     )
-    post_q1: Tuple[ops.Gate, ...] = field(
+    post_q1: tuple[ops.Gate, ...] = field(
         default=(), converter=lambda g: (g,) if isinstance(g, ops.Gate) else tuple(g)
     )
     swap_qubits: bool = False
@@ -88,12 +88,12 @@ class ConstantGauge(Gauge):
         return self
 
     @property
-    def pre(self) -> Tuple[Tuple[ops.Gate, ...], Tuple[ops.Gate, ...]]:
+    def pre(self) -> tuple[tuple[ops.Gate, ...], tuple[ops.Gate, ...]]:
         """A tuple (ops to apply to q0, ops to apply to q1)."""
         return self.pre_q0, self.pre_q1
 
     @property
-    def post(self) -> Tuple[Tuple[ops.Gate, ...], Tuple[ops.Gate, ...]]:
+    def post(self) -> tuple[tuple[ops.Gate, ...], tuple[ops.Gate, ...]]:
         """A tuple (ops to apply to q0, ops to apply to q1)."""
         return self.post_q0, self.post_q1
 
@@ -108,16 +108,16 @@ class ConstantGauge(Gauge):
 class SameGateGauge(Gauge):
     """Same as ConstantGauge but the new two-qubit gate equals the old gate."""
 
-    pre_q0: Tuple[ops.Gate, ...] = field(
+    pre_q0: tuple[ops.Gate, ...] = field(
         default=(), converter=lambda g: (g,) if isinstance(g, ops.Gate) else tuple(g)
     )
-    pre_q1: Tuple[ops.Gate, ...] = field(
+    pre_q1: tuple[ops.Gate, ...] = field(
         default=(), converter=lambda g: (g,) if isinstance(g, ops.Gate) else tuple(g)
     )
-    post_q0: Tuple[ops.Gate, ...] = field(
+    post_q0: tuple[ops.Gate, ...] = field(
         default=(), converter=lambda g: (g,) if isinstance(g, ops.Gate) else tuple(g)
     )
-    post_q1: Tuple[ops.Gate, ...] = field(
+    post_q1: tuple[ops.Gate, ...] = field(
         default=(), converter=lambda g: (g,) if isinstance(g, ops.Gate) else tuple(g)
     )
     swap_qubits: bool = False
@@ -144,12 +144,12 @@ class TwoQubitGateSymbolizer:
         n_symbols: The number of symbols to use for parameterization.
     """
 
-    symbolizer_fn: Callable[[ops.Gate, Sequence[sympy.Symbol]], Tuple[ops.Gate, Dict[str, Real]]]
+    symbolizer_fn: Callable[[ops.Gate, Sequence[sympy.Symbol]], tuple[ops.Gate, dict[str, Real]]]
     n_symbols: int
 
     def __call__(
         self, two_qubit_gate: ops.Gate, symbols: Sequence[sympy.Symbol]
-    ) -> Tuple[ops.Gate, Dict[str, Real]]:
+    ) -> tuple[ops.Gate, dict[str, Real]]:
         """Symbolizes a two qubit gate to a parameterized gate.
 
         Args:
@@ -197,9 +197,9 @@ class GaugeTransformer:
         self,
         # target can be either a specific gate, gatefamily or gateset
         # which allows matching parametric gates.
-        target: Union[ops.Gate, ops.Gateset, ops.GateFamily],
+        target: ops.Gate | ops.Gateset | ops.GateFamily,
         gauge_selector: Callable[[np.random.Generator], Gauge],
-        two_qubit_gate_symbolizer: Optional[TwoQubitGateSymbolizer] = None,
+        two_qubit_gate_symbolizer: TwoQubitGateSymbolizer | None = None,
     ) -> None:
         """Constructs a GaugeTransformer.
 
@@ -217,8 +217,8 @@ class GaugeTransformer:
         self,
         circuit: circuits.AbstractCircuit,
         *,
-        context: Optional[transformer_api.TransformerContext] = None,
-        prng: Optional[np.random.Generator] = None,
+        context: transformer_api.TransformerContext | None = None,
+        prng: np.random.Generator | None = None,
     ) -> circuits.AbstractCircuit:
         rng = np.random.default_rng() if prng is None else prng
         if context is None:
@@ -226,12 +226,12 @@ class GaugeTransformer:
         if context.deep:
             raise ValueError('GaugeTransformer cannot be used with deep=True')
         new_moments = []
-        left: List[List[ops.Operation]] = []
-        right: List[List[ops.Operation]] = []
+        left: list[list[ops.Operation]] = []
+        right: list[list[ops.Operation]] = []
         for moment in circuit:
             left.clear()
             right.clear()
-            center: List[ops.Operation] = []
+            center: list[ops.Operation] = []
             for op in moment:
                 if isinstance(op, ops.TaggedOperation) and set(op.tags).intersection(
                     context.tags_to_ignore
@@ -258,9 +258,9 @@ class GaugeTransformer:
         circuit: circuits.AbstractCircuit,
         *,
         N: int,
-        context: Optional[transformer_api.TransformerContext] = None,
-        prng: Optional[np.random.Generator] = None,
-    ) -> Tuple[circuits.AbstractCircuit, cirq.Sweepable]:
+        context: transformer_api.TransformerContext | None = None,
+        prng: np.random.Generator | None = None,
+    ) -> tuple[circuits.AbstractCircuit, cirq.Sweepable]:
         """Generates a parameterized circuit with *N* sets of sweepable parameters.
 
         Args:
@@ -276,31 +276,31 @@ class GaugeTransformer:
             context = transformer_api.TransformerContext(deep=False)
         if context.deep:
             raise ValueError('GaugeTransformer cannot be used with deep=True')
-        new_moments: List[List[ops.Operation]] = []  # Store parameterized circuits.
+        new_moments: list[list[ops.Operation]] = []  # Store parameterized circuits.
         phxz_sid = itertools.count()
         two_qubit_gate_sid = itertools.count()
         # Map from "((pre|post),$qid,$moment_id)" to gate parameters.
         # E.g., {(post,q1,2): {"x_exponent": "x1", "z_exponent": "z1", "axis_phase": "a1"}}
-        phxz_symbols_by_locs: Dict[Tuple[str, ops.Qid, int], Dict[str, sympy.Symbol]] = {}
+        phxz_symbols_by_locs: dict[tuple[str, ops.Qid, int], dict[str, sympy.Symbol]] = {}
         # Map from "($q0,$q1,$moment_id)" to gate parameters.
         # E.g., {(q0,q1,0): ["s0"]}.
-        two_qubit_gate_symbols_by_locs: Dict[Tuple[ops.Qid, ops.Qid, int], List[sympy.Symbol]] = {}
+        two_qubit_gate_symbols_by_locs: dict[tuple[ops.Qid, ops.Qid, int], list[sympy.Symbol]] = {}
 
-        def single_qubit_next_symbol() -> Dict[str, sympy.Symbol]:
+        def single_qubit_next_symbol() -> dict[str, sympy.Symbol]:
             sid = next(phxz_sid)
             return _parameterize_to_phxz(sid)
 
-        def two_qubit_gate_next_symbol_list(n: int) -> List[sympy.Symbol]:
+        def two_qubit_gate_next_symbol_list(n: int) -> list[sympy.Symbol]:
             """Returns symbols for 2 qubit gate parameterization."""
             sid = next(two_qubit_gate_sid)
-            symbols: List[sympy.Symbol] = [sympy.Symbol(f"s{sid}_{sub}") for sub in range(n)]
+            symbols: list[sympy.Symbol] = [sympy.Symbol(f"s{sid}_{sub}") for sub in range(n)]
             return symbols
 
         # Build parameterized circuit.
         for moment_id, moment in enumerate(circuit):
-            center_moment: List[ops.Operation] = []
-            left_moment: List[ops.Operation] = []
-            right_moment: List[ops.Operation] = []
+            center_moment: list[ops.Operation] = []
+            left_moment: list[ops.Operation] = []
+            right_moment: list[ops.Operation] = []
             for op in moment:
                 if isinstance(op, ops.TaggedOperation) and set(op.tags).intersection(
                     context.tags_to_ignore
@@ -342,7 +342,7 @@ class GaugeTransformer:
             )
 
         # Initialize the map from symbol names to their N values.
-        values_by_params: Dict[str, List[float]] = {
+        values_by_params: dict[str, list[float]] = {
             **{
                 str(symbol): []
                 for symbols_by_names in phxz_symbols_by_locs.values()
@@ -389,14 +389,14 @@ class GaugeTransformer:
                             for key, value in phxz_params.items():
                                 values_by_params[key].append(float(value))
 
-        sweeps: List[Points] = [
+        sweeps: list[Points] = [
             Points(key=key, points=values) for key, values in values_by_params.items()
         ]
 
         return circuits.Circuit.from_moments(*new_moments), Zip(*sweeps)
 
 
-def _build_moments(operation_by_qubits: List[List[ops.Operation]]) -> List[List[ops.Operation]]:
+def _build_moments(operation_by_qubits: list[list[ops.Operation]]) -> list[list[ops.Operation]]:
     """Builds moments from a list of operations grouped by qubits.
 
     Returns a list of moments from a list whose ith element is a list of operations applied
@@ -408,7 +408,7 @@ def _build_moments(operation_by_qubits: List[List[ops.Operation]]) -> List[List[
     return moments
 
 
-def _parameterize_to_phxz(symbol_id: int) -> Dict[str, sympy.Symbol]:
+def _parameterize_to_phxz(symbol_id: int) -> dict[str, sympy.Symbol]:
     """Returns symbolized parameters for the gate."""
 
     # Parameterize single qubit gate to parameterized PhasedXZGate.
@@ -421,8 +421,8 @@ def _parameterize_to_phxz(symbol_id: int) -> Dict[str, sympy.Symbol]:
 
 
 def _gate_sequence_to_phxz_params(
-    gates: Tuple[ops.Gate, ...], xza_by_symbols: Dict[str, sympy.Symbol]
-) -> Dict[str, float]:
+    gates: tuple[ops.Gate, ...], xza_by_symbols: dict[str, sympy.Symbol]
+) -> dict[str, float]:
     identity_gate_in_phxz = {
         str(xza_by_symbols["x_exponent"]): 0.0,
         str(xza_by_symbols["z_exponent"]): 0.0,

cirq/transformers/gauge_compiling/sqrt_cz_gauge.py

@@ -18,7 +18,7 @@
 from __future__ import annotations
 
 from numbers import Real
-from typing import Dict, Sequence, Tuple, TYPE_CHECKING
+from typing import Sequence, TYPE_CHECKING
 
 from cirq.ops import CZ, CZPowGate, Gate, Gateset, S, X
 from cirq.transformers.gauge_compiling.gauge_compiling import (
@@ -67,7 +67,7 @@ class SqrtCZGauge(Gauge):
 
 def _symbolize_as_cz_pow(
     two_qubit_gate: Gate, symbols: Sequence[sympy.Symbol]
-) -> Tuple[Gate, Dict[str, Real]]:
+) -> tuple[Gate, dict[str, Real]]:
     """Symbolizes a CZPowGate to a parameterized CZPowGate."""
 
     if not isinstance(two_qubit_gate, CZPowGate) or not isinstance(two_qubit_gate.exponent, Real):

cirq/transformers/heuristic_decompositions/two_qubit_gate_tabulation.py

@@ -19,7 +19,7 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 from functools import reduce
-from typing import List, NamedTuple, Sequence, Tuple
+from typing import NamedTuple, Sequence
 
 import numpy as np
 
@@ -34,7 +34,7 @@ from cirq.transformers.heuristic_decompositions.gate_tabulation_math_utils impor
     weyl_chamber_mesh,
 )
 
-_SingleQubitGatePair = Tuple[np.ndarray, np.ndarray]
+_SingleQubitGatePair = tuple[np.ndarray, np.ndarray]
 
 
 class TwoQubitGateTabulationResult(NamedTuple):
@@ -61,7 +61,7 @@ class TwoQubitGateTabulationResult(NamedTuple):
 
     base_gate_unitary: np.ndarray
     target_gate: np.ndarray
-    local_unitaries: Tuple[_SingleQubitGatePair, ...]
+    local_unitaries: tuple[_SingleQubitGatePair, ...]
     actual_gate: np.ndarray
     success: bool
 
@@ -82,7 +82,7 @@ class TwoQubitGateTabulation:
     summary: str  # Text summarizing the results of the tabulation procedure.
     # Any KAK vectors which are expected to be compilable (within infidelity
     # max_expected_infidelity) using 2 or 3 base gates.
-    missed_points: Tuple[np.ndarray, ...]
+    missed_points: tuple[np.ndarray, ...]
 
     def compile_two_qubit_gate(self, unitary: np.ndarray) -> TwoQubitGateTabulationResult:
         r"""Compute single qubit gates required to compile a desired unitary.
@@ -201,7 +201,7 @@ class TwoQubitGateTabulation:
 
 def _outer_locals_for_unitary(
     target: np.ndarray, base: np.ndarray
-) -> Tuple[_SingleQubitGatePair, _SingleQubitGatePair, np.ndarray]:
+) -> tuple[_SingleQubitGatePair, _SingleQubitGatePair, np.ndarray]:
     """Local unitaries mapping between locally equivalent 2-local unitaries.
 
     Finds the left and right 1-local unitaries kL, kR such that
@@ -246,10 +246,10 @@ def _outer_locals_for_unitary(
 
 class _TabulationStepResult(NamedTuple):
     # Generated KAK vectors that are uniquely close to at least one mesh point.
-    kept_kaks: List[np.ndarray]
+    kept_kaks: list[np.ndarray]
     # The corresponding single qubit unitaries required to obtain the desired
     # KAK vectors.
-    kept_cycles: List[Tuple[_SingleQubitGatePair, ...]]
+    kept_cycles: list[tuple[_SingleQubitGatePair, ...]]
 
 
 def _tabulate_kak_vectors(
@@ -361,7 +361,7 @@ def two_qubit_gate_product_tabulation(
 
     # include the base gate itself
     kak_vecs = [cirq.kak_vector(base_gate, check_preconditions=False)]
-    sq_cycles: List[Tuple[_SingleQubitGatePair, ...]] = [()]
+    sq_cycles: list[tuple[_SingleQubitGatePair, ...]] = [()]
 
     # Tabulate gates that are close to gates in the mesh
     u_locals_0 = random_qubit_unitary((num_samples,), rng=rng)

cirq/transformers/insertion_sort.py

@@ -16,7 +16,7 @@
 
 from __future__ import annotations
 
-from typing import Dict, List, Optional, TYPE_CHECKING
+from typing import TYPE_CHECKING
 
 from cirq import circuits, protocols
 from cirq.transformers import transformer_api
@@ -27,7 +27,7 @@ if TYPE_CHECKING:
 
 @transformer_api.transformer(add_deep_support=True)
 def insertion_sort_transformer(
-    circuit: cirq.AbstractCircuit, *, context: Optional[cirq.TransformerContext] = None
+    circuit: cirq.AbstractCircuit, *, context: cirq.TransformerContext | None = None
 ) -> cirq.Circuit:
     """Sorts the operations using their sorted `.qubits` property as comparison key.
 
@@ -37,11 +37,11 @@ def insertion_sort_transformer(
         circuit: input circuit.
         context: optional TransformerContext (not used),
     """
-    final_operations: List[cirq.Operation] = []
-    qubit_index: Dict[cirq.Qid, int] = {
+    final_operations: list[cirq.Operation] = []
+    qubit_index: dict[cirq.Qid, int] = {
         q: idx for idx, q in enumerate(sorted(circuit.all_qubits()))
     }
-    cached_qubit_indices: Dict[int, List[int]] = {}
+    cached_qubit_indices: dict[int, list[int]] = {}
     for pos, op in enumerate(circuit.all_operations()):
         # here `pos` is at the append position of final_operations
         if (op_qubit_indices := cached_qubit_indices.get(id(op))) is None:

cirq/transformers/measurement_transformers.py

@@ -16,7 +16,7 @@ from __future__ import annotations
 
 import itertools
 from collections import defaultdict
-from typing import Any, cast, Dict, Iterable, List, Optional, Sequence, Tuple, TYPE_CHECKING, Union
+from typing import Any, cast, Iterable, Sequence, TYPE_CHECKING
 
 import numpy as np
 
@@ -35,7 +35,7 @@ class _MeasurementQid(ops.Qid):
     Exactly one qubit will be created per qubit in the measurement gate.
     """
 
-    def __init__(self, key: Union[str, cirq.MeasurementKey], qid: cirq.Qid, index: int = 0):
+    def __init__(self, key: str | cirq.MeasurementKey, qid: cirq.Qid, index: int = 0):
         """Initializes the qubit.
 
         Args:
@@ -65,7 +65,7 @@ class _MeasurementQid(ops.Qid):
 
 @transformer_api.transformer
 def defer_measurements(
-    circuit: cirq.AbstractCircuit, *, context: Optional[cirq.TransformerContext] = None
+    circuit: cirq.AbstractCircuit, *, context: cirq.TransformerContext | None = None
 ) -> cirq.Circuit:
     """Implements the Deferred Measurement Principle.
 
@@ -96,7 +96,7 @@ def defer_measurements(
 
     circuit = transformer_primitives.unroll_circuit_op(circuit, deep=True, tags_to_check=None)
     terminal_measurements = {op for _, op in find_terminal_measurements(circuit)}
-    measurement_qubits: Dict[cirq.MeasurementKey, List[Tuple[cirq.Qid, ...]]] = defaultdict(list)
+    measurement_qubits: dict[cirq.MeasurementKey, list[tuple[cirq.Qid, ...]]] = defaultdict(list)
 
     def defer(op: cirq.Operation, _) -> cirq.OP_TREE:
         if op in terminal_measurements:
@@ -169,8 +169,8 @@ def defer_measurements(
 
 
 def _all_possible_datastore_states(
-    keys: Iterable[Tuple[cirq.MeasurementKey, int]],
-    measurement_qubits: Dict[cirq.MeasurementKey, List[Tuple[cirq.Qid, ...]]],
+    keys: Iterable[tuple[cirq.MeasurementKey, int]],
+    measurement_qubits: dict[cirq.MeasurementKey, list[tuple[cirq.Qid, ...]]],
 ) -> Iterable[cirq.ClassicalDataStoreReader]:
     """The cartesian product of all possible DataStore states for the given keys."""
     # First we get the list of all possible values. So if we have a key mapped to qubits of shape
@@ -216,7 +216,7 @@ def _all_possible_datastore_states(
 def dephase_measurements(
     circuit: cirq.AbstractCircuit,
     *,
-    context: Optional[cirq.TransformerContext] = transformer_api.TransformerContext(deep=True),
+    context: cirq.TransformerContext | None = transformer_api.TransformerContext(deep=True),
 ) -> cirq.Circuit:
     """Changes all measurements to a dephase operation.
 
@@ -259,7 +259,7 @@ def dephase_measurements(
 def drop_terminal_measurements(
     circuit: cirq.AbstractCircuit,
     *,
-    context: Optional[cirq.TransformerContext] = transformer_api.TransformerContext(deep=True),
+    context: cirq.TransformerContext | None = transformer_api.TransformerContext(deep=True),
 ) -> cirq.Circuit:
     """Removes terminal measurements from a circuit.
 
@@ -426,20 +426,20 @@ class _ConfusionChannel(ops.Gate):
         self._confusion_map = confusion_map.copy()
         self._kraus = tuple(kraus)
 
-    def _qid_shape_(self) -> Tuple[int, ...]:
+    def _qid_shape_(self) -> tuple[int, ...]:
         return self._shape
 
-    def _kraus_(self) -> Tuple[np.ndarray, ...]:
+    def _kraus_(self) -> tuple[np.ndarray, ...]:
         return self._kraus
 
     def _apply_channel_(self, args: cirq.ApplyChannelArgs):
-        configs: List[transformations._BuildFromSlicesArgs] = []
+        configs: list[transformations._BuildFromSlicesArgs] = []
         for i in range(np.prod(self._shape) ** 2):
             scale = cast(complex, self._confusion_map.flat[i])
             if scale == 0:
                 continue
             index: Any = np.unravel_index(i, self._shape * 2)
-            slices: List[transformations._SliceConfig] = []
+            slices: list[transformations._SliceConfig] = []
             axis_count = len(args.left_axes)
             for j in range(axis_count):
                 s1 = transformations._SliceConfig(
@@ -469,13 +469,13 @@ class _ModAdd(ops.ArithmeticGate):
     def __init__(self, dimension: int):
         self._dimension = dimension
 
-    def registers(self) -> Tuple[Tuple[int], Tuple[int]]:
+    def registers(self) -> tuple[tuple[int], tuple[int]]:
         return (self._dimension,), (self._dimension,)
 
     def with_registers(self, *new_registers) -> _ModAdd:
         raise NotImplementedError()
 
-    def apply(self, *register_values: int) -> Tuple[int, int]:
+    def apply(self, *register_values: int) -> tuple[int, int]:
         return register_values[0], sum(register_values)
 
     def _value_equality_values_(self) -> int:

cirq/transformers/merge_k_qubit_gates_test.py

@@ -16,8 +16,6 @@
 
 from __future__ import annotations
 
-from typing import List
-
 import numpy as np
 import pytest
 
@@ -26,7 +24,7 @@ import cirq
 
 def assert_optimizes(optimized: cirq.AbstractCircuit, expected: cirq.AbstractCircuit):
     # Ignore differences that would be caught by follow-up optimizations.
-    followup_transformers: List[cirq.TRANSFORMER] = [
+    followup_transformers: list[cirq.TRANSFORMER] = [
         cirq.drop_negligible_operations,
         cirq.drop_empty_moments,
     ]

cirq/transformers/merge_single_qubit_gates_test.py

@@ -14,14 +14,12 @@
 
 from __future__ import annotations
 
-from typing import List
-
 import cirq
 
 
 def assert_optimizes(optimized: cirq.AbstractCircuit, expected: cirq.AbstractCircuit):
     # Ignore differences that would be caught by follow-up optimizations.
-    followup_transformers: List[cirq.TRANSFORMER] = [
+    followup_transformers: list[cirq.TRANSFORMER] = [
         cirq.drop_negligible_operations,
         cirq.drop_empty_moments,
     ]