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

cirq/devices/superconducting_qubits_noise_properties.py

@@ -19,7 +19,7 @@ from __future__ import annotations
 import abc
 from dataclasses import dataclass, field
 from functools import cached_property
-from typing import Dict, List, Set, Type, TYPE_CHECKING
+from typing import TYPE_CHECKING
 
 from cirq import devices, ops, qis
 from cirq.devices import noise_utils
@@ -34,11 +34,11 @@ class SuperconductingQubitsNoiseProperties(devices.NoiseProperties, abc.ABC):
     """Noise-defining properties for a superconducting-qubit-based device.
 
     Args:
-        gate_times_ns: Dict[type, float] of gate types to their duration on
+        gate_times_ns: dict[type, float] of gate types to their duration on
             quantum hardware. Used with t(1|phi)_ns to specify thermal noise.
-        t1_ns: Dict[cirq.Qid, float] of qubits to their T_1 time, in ns.
-        tphi_ns: Dict[cirq.Qid, float] of qubits to their T_phi time, in ns.
-        readout_errors: Dict[cirq.Qid, np.ndarray] of qubits to their readout
+        t1_ns: dict[cirq.Qid, float] of qubits to their T_1 time, in ns.
+        tphi_ns: dict[cirq.Qid, float] of qubits to their T_phi time, in ns.
+        readout_errors: dict[cirq.Qid, np.ndarray] of qubits to their readout
             errors in matrix form: [P(read |1> from |0>), P(read |0> from |1>)].
             Used to prepend amplitude damping errors to measurements.
         gate_pauli_errors: dict of noise_utils.OpIdentifiers (a gate and the qubits it
@@ -49,14 +49,14 @@ class SuperconductingQubitsNoiseProperties(devices.NoiseProperties, abc.ABC):
             symmetric over the qubits they affect. Defaults to True.
     """
 
-    gate_times_ns: Dict[type, float]
-    t1_ns: Dict[cirq.Qid, float]
-    tphi_ns: Dict[cirq.Qid, float]
-    readout_errors: Dict[cirq.Qid, List[float]]
-    gate_pauli_errors: Dict[noise_utils.OpIdentifier, float]
+    gate_times_ns: dict[type, float]
+    t1_ns: dict[cirq.Qid, float]
+    tphi_ns: dict[cirq.Qid, float]
+    readout_errors: dict[cirq.Qid, list[float]]
+    gate_pauli_errors: dict[noise_utils.OpIdentifier, float]
 
     validate: bool = True
-    _qubits: List[cirq.Qid] = field(init=False, default_factory=list)
+    _qubits: list[cirq.Qid] = field(init=False, default_factory=list)
 
     def __post_init__(self):
         if not self.validate:
@@ -96,7 +96,7 @@ class SuperconductingQubitsNoiseProperties(devices.NoiseProperties, abc.ABC):
                 )
 
     @property
-    def qubits(self) -> List[cirq.Qid]:
+    def qubits(self) -> list[cirq.Qid]:
         """Qubits for which we have data"""
         if not self._qubits:
             self._qubits = sorted(self.t1_ns)
@@ -104,26 +104,26 @@ class SuperconductingQubitsNoiseProperties(devices.NoiseProperties, abc.ABC):
 
     @classmethod
     @abc.abstractmethod
-    def single_qubit_gates(cls) -> Set[Type[ops.Gate]]:
+    def single_qubit_gates(cls) -> set[type[ops.Gate]]:
         """Returns the set of single-qubit gates this class supports."""
 
     @classmethod
     @abc.abstractmethod
-    def symmetric_two_qubit_gates(cls) -> Set[Type[ops.Gate]]:
+    def symmetric_two_qubit_gates(cls) -> set[type[ops.Gate]]:
         """Returns the set of symmetric two-qubit gates this class supports."""
 
     @classmethod
     @abc.abstractmethod
-    def asymmetric_two_qubit_gates(cls) -> Set[Type[ops.Gate]]:
+    def asymmetric_two_qubit_gates(cls) -> set[type[ops.Gate]]:
         """Returns the set of asymmetric two-qubit gates this class supports."""
 
     @classmethod
-    def two_qubit_gates(cls) -> Set[Type[ops.Gate]]:
+    def two_qubit_gates(cls) -> set[type[ops.Gate]]:
         """Returns the set of all two-qubit gates this class supports."""
         return cls.symmetric_two_qubit_gates() | cls.asymmetric_two_qubit_gates()
 
     @classmethod
-    def expected_gates(cls) -> Set[Type[ops.Gate]]:
+    def expected_gates(cls) -> set[type[ops.Gate]]:
         """Returns the set of all gates this class supports."""
         return cls.single_qubit_gates() | cls.two_qubit_gates()
 
@@ -134,7 +134,7 @@ class SuperconductingQubitsNoiseProperties(devices.NoiseProperties, abc.ABC):
         return p_error
 
     @cached_property
-    def _depolarizing_error(self) -> Dict[noise_utils.OpIdentifier, float]:
+    def _depolarizing_error(self) -> dict[noise_utils.OpIdentifier, float]:
         """Returns the portion of Pauli error from depolarization."""
         depol_errors = {}
         for op_id, p_error in self.gate_pauli_errors.items():
@@ -151,8 +151,8 @@ class SuperconductingQubitsNoiseProperties(devices.NoiseProperties, abc.ABC):
             depol_errors[op_id] = self._get_pauli_error(p_error, op_id)
         return depol_errors
 
-    def build_noise_models(self) -> List[cirq.NoiseModel]:
-        noise_models: List[cirq.NoiseModel] = []
+    def build_noise_models(self) -> list[cirq.NoiseModel]:
+        noise_models: list[cirq.NoiseModel] = []
 
         if self.t1_ns:
             noise_models.append(
@@ -176,7 +176,7 @@ class SuperconductingQubitsNoiseProperties(devices.NoiseProperties, abc.ABC):
 
         # This adds per-qubit measurement error BEFORE measurement on those qubits.
         if self.readout_errors:
-            added_measure_errors: Dict[noise_utils.OpIdentifier, cirq.Operation] = {}
+            added_measure_errors: dict[noise_utils.OpIdentifier, cirq.Operation] = {}
             for qubit in self.readout_errors:
                 p_00, p_11 = self.readout_errors[qubit]
                 p = p_11 / (p_00 + p_11)

cirq/devices/superconducting_qubits_noise_properties_test.py

@@ -14,8 +14,6 @@
 
 from __future__ import annotations
 
-from typing import Dict, List, Set, Tuple
-
 import numpy as np
 import pytest
 
@@ -26,7 +24,7 @@ from cirq.devices.superconducting_qubits_noise_properties import (
     SuperconductingQubitsNoiseProperties,
 )
 
-DEFAULT_GATE_NS: Dict[type, float] = {
+DEFAULT_GATE_NS: dict[type, float] = {
     cirq.ZPowGate: 25.0,
     cirq.MeasurementGate: 4000.0,
     cirq.ResetChannel: 250.0,
@@ -39,7 +37,7 @@ DEFAULT_GATE_NS: Dict[type, float] = {
 }
 
 
-def default_props(system_qubits: List[cirq.Qid], qubit_pairs: List[Tuple[cirq.Qid, cirq.Qid]]):
+def default_props(system_qubits: list[cirq.Qid], qubit_pairs: list[tuple[cirq.Qid, cirq.Qid]]):
     return {
         'gate_times_ns': DEFAULT_GATE_NS,
         't1_ns': {q: 1e5 for q in system_qubits},
@@ -65,15 +63,15 @@ class ExampleNoiseProperties(SuperconductingQubitsNoiseProperties):
         super().__init__(*args, **kwargs)
 
     @classmethod
-    def single_qubit_gates(cls) -> Set[type]:
+    def single_qubit_gates(cls) -> set[type]:
         return {cirq.ZPowGate, cirq.PhasedXZGate, cirq.MeasurementGate, cirq.ResetChannel}
 
     @classmethod
-    def symmetric_two_qubit_gates(cls) -> Set[type]:
+    def symmetric_two_qubit_gates(cls) -> set[type]:
         return {cirq.FSimGate, cirq.PhasedFSimGate, cirq.ISwapPowGate, cirq.CZPowGate}
 
     @classmethod
-    def asymmetric_two_qubit_gates(cls) -> Set[type]:
+    def asymmetric_two_qubit_gates(cls) -> set[type]:
         return set()
 
 

cirq/devices/thermal_noise_model.py

@@ -16,7 +16,7 @@ from __future__ import annotations
 
 import dataclasses
 import functools
-from typing import Dict, List, Optional, Sequence, Set, Tuple, TYPE_CHECKING, Union
+from typing import Sequence, TYPE_CHECKING
 
 import numpy as np
 import sympy
@@ -81,7 +81,7 @@ def _lindbladian(left_op: np.ndarray) -> np.ndarray:
 
 @functools.lru_cache(maxsize=256)
 def _kraus_ops_from_rates(
-    flat_rates: Tuple[float, ...], shape: Tuple[int, int]
+    flat_rates: tuple[float, ...], shape: tuple[int, int]
 ) -> Sequence[np.ndarray]:
     """Generate kraus operators from an array of rates.
 
@@ -131,8 +131,8 @@ def _decoherence_matrix(
 
 
 def _as_rate_dict(
-    rate_or_dict: Optional[Union[float, Dict[cirq.Qid, float]]], qubits: Set[cirq.Qid]
-) -> Dict[cirq.Qid, float]:
+    rate_or_dict: float | dict[cirq.Qid, float] | None, qubits: set[cirq.Qid]
+) -> dict[cirq.Qid, float]:
     """Convert float or None input into dictionary form.
 
     This method also ensures that no qubits are missing from dictionary keys.
@@ -145,7 +145,7 @@ def _as_rate_dict(
         return {q: rate_or_dict for q in qubits}
 
 
-def _validate_rates(qubits: Set[cirq.Qid], rates: Dict[cirq.Qid, np.ndarray]) -> None:
+def _validate_rates(qubits: set[cirq.Qid], rates: dict[cirq.Qid, np.ndarray]) -> None:
     """Check all rate matrices are square and of appropriate dimension.
 
     We check rates are positive in the class validator.
@@ -171,11 +171,11 @@ class ThermalNoiseModel(devices.NoiseModel):
 
     def __init__(
         self,
-        qubits: Set[cirq.Qid],
-        gate_durations_ns: Dict[type, float],
-        heat_rate_GHz: Union[float, Dict[cirq.Qid, float], None] = None,
-        cool_rate_GHz: Union[float, Dict[cirq.Qid, float], None] = None,
-        dephase_rate_GHz: Union[float, Dict[cirq.Qid, float], None] = None,
+        qubits: set[cirq.Qid],
+        gate_durations_ns: dict[type, float],
+        heat_rate_GHz: float | dict[cirq.Qid, float] | None = None,
+        cool_rate_GHz: float | dict[cirq.Qid, float] | None = None,
+        dephase_rate_GHz: float | dict[cirq.Qid, float] | None = None,
         require_physical_tag: bool = True,
         skip_measurements: bool = True,
         prepend: bool = False,
@@ -226,8 +226,8 @@ class ThermalNoiseModel(devices.NoiseModel):
             rate_dict[q] = _decoherence_matrix(gamma_c, gamma_phi, gamma_h, q.dimension)
 
         _validate_rates(qubits, rate_dict)
-        self.gate_durations_ns: Dict[type, float] = gate_durations_ns
-        self.rate_matrix_GHz: Dict[cirq.Qid, np.ndarray] = rate_dict
+        self.gate_durations_ns: dict[type, float] = gate_durations_ns
+        self.rate_matrix_GHz: dict[cirq.Qid, np.ndarray] = rate_dict
         self.require_physical_tag: bool = require_physical_tag
         self.skip_measurements: bool = skip_measurements
         self._prepend = prepend
@@ -247,13 +247,13 @@ class ThermalNoiseModel(devices.NoiseModel):
                 # Only moments with physical operations should have noise.
                 return [moment]
 
-        noise_ops: List[cirq.Operation] = []
+        noise_ops: list[cirq.Operation] = []
         # Some devices (including Google hardware) require that all gates have
         # the same duration, but this does not. Instead, each moment is assumed
         # to be as long as the longest gate it contains.
         moment_ns: float = 0
         for op in moment:
-            op_duration: Optional[float] = None
+            op_duration: float | None = None
             for key, duration in self.gate_durations_ns.items():
                 if not issubclass(type(op.gate), key):
                     continue  # gate type doesn't match

cirq/devices/unconstrained_device.py

@@ -14,7 +14,7 @@
 
 from __future__ import annotations
 
-from typing import Any, Dict, TYPE_CHECKING
+from typing import Any, TYPE_CHECKING
 
 from cirq import protocols, value
 from cirq._doc import document
@@ -43,7 +43,7 @@ class _UnconstrainedDevice(device.Device):
     def _value_equality_values_(self) -> Any:
         return ()
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(self, [])
 
 

cirq/experiments/benchmarking/parallel_xeb.py

@@ -17,7 +17,7 @@
 from __future__ import annotations
 
 from concurrent import futures
-from typing import Dict, Optional, overload, Sequence, TYPE_CHECKING, Union
+from typing import overload, Sequence, TYPE_CHECKING, Union
 
 import attrs
 import networkx as nx
@@ -34,7 +34,7 @@ if TYPE_CHECKING:
 
 _TARGET_T = Union['cirq.Gate', 'cirq.Operation', 'cirq.AbstractCircuit']
 _QUBIT_PAIR_T = tuple['cirq.GridQubit', 'cirq.GridQubit']
-_CANONICAL_TARGET_T = Union['cirq.Operation', Dict[_QUBIT_PAIR_T, 'cirq.Operation']]
+_CANONICAL_TARGET_T = Union['cirq.Operation', dict[_QUBIT_PAIR_T, 'cirq.Operation']]
 _PROBABILITIES_DICT_T = dict[_QUBIT_PAIR_T, list[list[np.ndarray]]]
 
 
@@ -76,7 +76,7 @@ class XEBWideCircuitInfo:
         converter=lambda seq: [_canonize_pair(pair) for pair in seq]
     )
     narrow_template_indices: tuple[int, ...] = attrs.field(converter=tuple)
-    cycle_depth: Optional[int] = None
+    cycle_depth: int | None = None
 
     @staticmethod
     def from_narrow_circuits(
@@ -166,9 +166,7 @@ def _target_to_operation(target: _TARGET_T) -> cirq.Operation:
     return target
 
 
-def _canonize_target(
-    target: Union[_TARGET_T, Dict[_QUBIT_PAIR_T, _TARGET_T]],
-) -> _CANONICAL_TARGET_T:
+def _canonize_target(target: _TARGET_T | dict[_QUBIT_PAIR_T, _TARGET_T]) -> _CANONICAL_TARGET_T:
     if isinstance(target, (ops.Gate, ops.Operation, circuits.AbstractCircuit)):
         return _target_to_operation(target)
     return {k: _target_to_operation(v) for k, v in target.items()}
@@ -267,7 +265,7 @@ def simulate_circuit_library(
     circuit_templates: Sequence[cirq.Circuit],
     target_or_dict: ops.Operation,
     cycle_depths: Sequence[int],
-    pool: Optional[futures.Executor] = None,
+    pool: futures.Executor | None = None,
 ) -> Sequence[Sequence[np.ndarray]]: ...
 
 
@@ -276,7 +274,7 @@ def simulate_circuit_library(
     circuit_templates: Sequence[cirq.Circuit],
     target_or_dict: dict[_QUBIT_PAIR_T, ops.Operation],
     cycle_depths: Sequence[int],
-    pool: Optional[futures.Executor] = None,
+    pool: futures.Executor | None = None,
 ) -> dict[_QUBIT_PAIR_T, Sequence[Sequence[np.ndarray]]]: ...
 
 
@@ -284,8 +282,8 @@ def simulate_circuit_library(
     circuit_templates: Sequence[cirq.Circuit],
     target_or_dict: _CANONICAL_TARGET_T,
     cycle_depths: Sequence[int],
-    pool: Optional[futures.Executor] = None,
-) -> Union[Sequence[Sequence[np.ndarray]], dict[_QUBIT_PAIR_T, Sequence[Sequence[np.ndarray]]]]:
+    pool: futures.Executor | None = None,
+) -> Sequence[Sequence[np.ndarray]] | dict[_QUBIT_PAIR_T, Sequence[Sequence[np.ndarray]]]:
     """Simulate the given sequence of circuits.
 
     Args:
@@ -408,9 +406,9 @@ def _reshape_sampling_results(
 
 
 def _reshape_simulation_results(
-    simulation_results: Union[
-        Sequence[Sequence[np.ndarray]], dict[_QUBIT_PAIR_T, Sequence[Sequence[np.ndarray]]]
-    ],
+    simulation_results: (
+        Sequence[Sequence[np.ndarray]] | dict[_QUBIT_PAIR_T, Sequence[Sequence[np.ndarray]]]
+    ),
     cycle_depths: Sequence[int],
     pairs: Sequence[_QUBIT_PAIR_T],
     num_templates: int,
@@ -464,9 +462,9 @@ def _cross_entropy(p: np.ndarray, q: np.ndarray, eps: float = 1e-60) -> float:
 
 def estimate_fidelities(
     sampling_results: Sequence[dict[str, np.ndarray]],
-    simulation_results: Union[
-        Sequence[Sequence[np.ndarray]], dict[_QUBIT_PAIR_T, Sequence[Sequence[np.ndarray]]]
-    ],
+    simulation_results: (
+        Sequence[Sequence[np.ndarray]] | dict[_QUBIT_PAIR_T, Sequence[Sequence[np.ndarray]]]
+    ),
     cycle_depths: Sequence[int],
     wide_circuits_info: Sequence[XEBWideCircuitInfo],
     pairs: Sequence[_QUBIT_PAIR_T],
@@ -527,9 +525,9 @@ def estimate_fidelities(
 
 def _extract_pairs(
     sampler: cirq.Sampler,
-    target: Union[_TARGET_T, Dict[_QUBIT_PAIR_T, _TARGET_T]],
-    qubits: Optional[Sequence[cirq.GridQubit]],
-    pairs: Optional[Sequence[_QUBIT_PAIR_T]],
+    target: _TARGET_T | dict[_QUBIT_PAIR_T, _TARGET_T],
+    qubits: Sequence[cirq.GridQubit] | None,
+    pairs: Sequence[_QUBIT_PAIR_T] | None,
 ) -> Sequence[_QUBIT_PAIR_T]:
     if isinstance(target, dict):
         if pairs is None:
@@ -547,13 +545,13 @@ def _extract_pairs(
 
 def parallel_xeb_workflow(
     sampler: cirq.Sampler,
-    target: Union[_TARGET_T, Dict[_QUBIT_PAIR_T, _TARGET_T]],
-    ideal_target: Optional[Union[_TARGET_T, Dict[_QUBIT_PAIR_T, _TARGET_T]]] = None,
-    qubits: Optional[Sequence[cirq.GridQubit]] = None,
-    pairs: Optional[Sequence[_QUBIT_PAIR_T]] = None,
+    target: _TARGET_T | dict[_QUBIT_PAIR_T, _TARGET_T],
+    ideal_target: _TARGET_T | dict[_QUBIT_PAIR_T, _TARGET_T] | None = None,
+    qubits: Sequence[cirq.GridQubit] | None = None,
+    pairs: Sequence[_QUBIT_PAIR_T] | None = None,
     parameters: XEBParameters = XEBParameters(),
-    rng: Optional[np.random.Generator] = None,
-    pool: Optional[futures.Executor] = None,
+    rng: np.random.Generator | None = None,
+    pool: futures.Executor | None = None,
 ) -> Sequence[XEBFidelity]:
     """A utility method that runs the full XEB workflow.
 
@@ -646,13 +644,13 @@ def parallel_xeb_workflow(
 
 def parallel_two_qubit_xeb(
     sampler: cirq.Sampler,
-    target: Union[_TARGET_T, Dict[_QUBIT_PAIR_T, _TARGET_T]],
-    ideal_target: Optional[Union[_TARGET_T, Dict[_QUBIT_PAIR_T, _TARGET_T]]] = None,
-    qubits: Optional[Sequence[cirq.GridQubit]] = None,
-    pairs: Optional[Sequence[_QUBIT_PAIR_T]] = None,
+    target: _TARGET_T | dict[_QUBIT_PAIR_T, _TARGET_T],
+    ideal_target: _TARGET_T | dict[_QUBIT_PAIR_T, _TARGET_T] | None = None,
+    qubits: Sequence[cirq.GridQubit] | None = None,
+    pairs: Sequence[_QUBIT_PAIR_T] | None = None,
     parameters: XEBParameters = XEBParameters(),
-    rng: Optional[np.random.Generator] = None,
-    pool: Optional[futures.Executor] = None,
+    rng: np.random.Generator | None = None,
+    pool: futures.Executor | None = None,
 ) -> tqxeb.TwoQubitXEBResult:
     """A convenience method that runs the full XEB workflow.
 

cirq/experiments/n_qubit_tomography.py

@@ -20,7 +20,7 @@ so that occurs outside of the StateTomographyExperiment class.
 
 from __future__ import annotations
 
-from typing import List, Optional, Sequence, Tuple, TYPE_CHECKING
+from typing import Sequence, TYPE_CHECKING
 
 import numpy as np
 import sympy
@@ -51,9 +51,7 @@ class StateTomographyExperiment:
     """
 
     def __init__(
-        self,
-        qubits: Sequence[cirq.Qid],
-        prerotations: Optional[Sequence[Tuple[float, float]]] = None,
+        self, qubits: Sequence[cirq.Qid], prerotations: Sequence[tuple[float, float]] | None = None
     ):
         """Initializes the rotation protocol and matrix for system.
 
@@ -72,8 +70,8 @@ class StateTomographyExperiment:
 
         phase_exp_vals, exp_vals = zip(*prerotations)
 
-        operations: List[cirq.Operation] = []
-        sweeps: List[cirq.Sweep] = []
+        operations: list[cirq.Operation] = []
+        sweeps: list[cirq.Sweep] = []
         for i, qubit in enumerate(qubits):
             phase_exp = sympy.Symbol(f'phase_exp_{i}')
             exp = sympy.Symbol(f'exp_{i}')
@@ -137,7 +135,7 @@ def state_tomography(
     qubits: Sequence[cirq.Qid],
     circuit: cirq.Circuit,
     repetitions: int = 1000,
-    prerotations: Optional[Sequence[Tuple[float, float]]] = None,
+    prerotations: Sequence[tuple[float, float]] | None = None,
 ) -> TomographyResult:
     """This performs n qubit tomography on a cirq circuit
 

cirq/experiments/qubit_characterizations.py

@@ -17,18 +17,7 @@ from __future__ import annotations
 import dataclasses
 import functools
 import itertools
-from typing import (
-    Any,
-    cast,
-    Dict,
-    Iterator,
-    List,
-    Mapping,
-    Optional,
-    Sequence,
-    Tuple,
-    TYPE_CHECKING,
-)
+from typing import Any, cast, Iterator, Mapping, Sequence, TYPE_CHECKING
 
 import numpy as np
 from matplotlib import pyplot as plt
@@ -65,11 +54,11 @@ class Cliffords:
         s1_y
     """
 
-    c1_in_xy: List[List[ops.SingleQubitCliffordGate]]
-    c1_in_xz: List[List[ops.SingleQubitCliffordGate]]
-    s1: List[List[ops.SingleQubitCliffordGate]]
-    s1_x: List[List[ops.SingleQubitCliffordGate]]
-    s1_y: List[List[ops.SingleQubitCliffordGate]]
+    c1_in_xy: list[list[ops.SingleQubitCliffordGate]]
+    c1_in_xz: list[list[ops.SingleQubitCliffordGate]]
+    s1: list[list[ops.SingleQubitCliffordGate]]
+    s1_x: list[list[ops.SingleQubitCliffordGate]]
+    s1_y: list[list[ops.SingleQubitCliffordGate]]
 
 
 class RandomizedBenchMarkResult:
@@ -88,14 +77,14 @@ class RandomizedBenchMarkResult:
         self._gnd_state_probs = ground_state_probabilities
 
     @property
-    def data(self) -> Sequence[Tuple[int, float]]:
+    def data(self) -> Sequence[tuple[int, float]]:
         """Returns a sequence of tuple pairs with the first item being a
         number of Cliffords and the second item being the corresponding average
         ground state probability.
         """
         return [(num, prob) for num, prob in zip(self._num_cfds_seq, self._gnd_state_probs)]
 
-    def plot(self, ax: Optional[plt.Axes] = None, **plot_kwargs: Any) -> plt.Axes:
+    def plot(self, ax: plt.Axes | None = None, **plot_kwargs: Any) -> plt.Axes:
         """Plots the average ground state probability vs the number of
         Cliffords in the RB study.
 
@@ -138,7 +127,7 @@ class RandomizedBenchMarkResult:
         p = opt_params[2]
         return (1.0 - 1.0 / 4.0) * (1.0 - p)
 
-    def _fit_exponential(self) -> Tuple[np.ndarray, np.ndarray]:
+    def _fit_exponential(self) -> tuple[np.ndarray, np.ndarray]:
         exp_fit = lambda x, A, B, p: A * p**x + B
         return curve_fit(
             f=exp_fit,
@@ -156,7 +145,7 @@ class ParallelRandomizedBenchmarkingResult:
     results_dictionary: Mapping[cirq.Qid, RandomizedBenchMarkResult]
 
     def plot_single_qubit(
-        self, qubit: cirq.Qid, ax: Optional[plt.Axes] = None, **plot_kwargs: Any
+        self, qubit: cirq.Qid, ax: plt.Axes | None = None, **plot_kwargs: Any
     ) -> plt.Axes:
         """Plot the raw data for the specified qubit.
 
@@ -183,7 +172,7 @@ class ParallelRandomizedBenchmarkingResult:
 
     def plot_heatmap(
         self,
-        ax: Optional[plt.Axes] = None,
+        ax: plt.Axes | None = None,
         annotation_format: str = '0.1%',
         title: str = 'Single-qubit Pauli error',
         **plot_kwargs: Any,
@@ -216,16 +205,16 @@ class ParallelRandomizedBenchmarkingResult:
 
     def plot_integrated_histogram(
         self,
-        ax: Optional[plt.Axes] = None,
+        ax: plt.Axes | None = None,
         cdf_on_x: bool = False,
         axis_label: str = 'Pauli error',
         semilog: bool = True,
         median_line: bool = True,
-        median_label: Optional[str] = 'median',
+        median_label: str | None = 'median',
         mean_line: bool = False,
-        mean_label: Optional[str] = 'mean',
+        mean_label: str | None = 'mean',
         show_zero: bool = False,
-        title: Optional[str] = None,
+        title: str | None = None,
         **kwargs,
     ) -> plt.Axes:
         """Plot the Pauli errors using cirq.integrated_histogram().
@@ -289,8 +278,8 @@ class TomographyResult:
         return self._density_matrix
 
     def plot(
-        self, axes: Optional[List[plt.Axes]] = None, **plot_kwargs: Any
-    ) -> List[plt.Axes]:  # pragma: no cover
+        self, axes: list[plt.Axes] | None = None, **plot_kwargs: Any
+    ) -> list[plt.Axes]:  # pragma: no cover
         """Plots the real and imaginary parts of the density matrix as two 3D bar plots.
 
         Args:
@@ -433,7 +422,7 @@ def parallel_single_qubit_randomized_benchmarking(
     c1 = clifford_group.c1_in_xy if use_xy_basis else clifford_group.c1_in_xz
 
     # create circuits
-    circuits_all: List[cirq.AbstractCircuit] = []
+    circuits_all: list[cirq.AbstractCircuit] = []
     for num_cliffords in num_clifford_range:
         for _ in range(num_circuits):
             circuits_all.append(_create_parallel_rb_circuit(qubits, num_cliffords, c1))
@@ -443,7 +432,7 @@ def parallel_single_qubit_randomized_benchmarking(
     gnd_probs: dict = {q: [] for q in qubits}
     idx = 0
     for num_cliffords in num_clifford_range:
-        excited_probs: Dict[cirq.Qid, List[float]] = {q: [] for q in qubits}
+        excited_probs: dict[cirq.Qid, list[float]] = {q: [] for q in qubits}
         for _ in range(num_circuits):
             result = results[idx][0]
             for qubit in qubits:
@@ -702,7 +691,7 @@ def _create_parallel_rb_circuit(
     return circuits.Circuit.from_moments(*moments, ops.measure_each(*qubits))
 
 
-def _indices_after_basis_rot(i: int, j: int) -> Tuple[int, Sequence[int], Sequence[int]]:
+def _indices_after_basis_rot(i: int, j: int) -> tuple[int, Sequence[int], Sequence[int]]:
     mat_idx = 3 * (3 * i + j)
     q_0_i = 3 - i
     q_1_j = 3 - j
@@ -742,7 +731,7 @@ def _two_qubit_clifford_matrices(q_0: cirq.Qid, q_1: cirq.Qid, cliffords: Cliffo
 
 def _random_single_q_clifford(
     qubit: cirq.Qid, num_cfds: int, cfds: Sequence[Sequence[cirq.ops.SingleQubitCliffordGate]]
-) -> List[cirq.Operation]:
+) -> list[cirq.Operation]:
     clifford_group_size = 24
     operations = [[gate.to_phased_xz_gate()(qubit) for gate in gates] for gates in cfds]
     gate_ids = np.random.choice(clifford_group_size, num_cfds).tolist()
@@ -776,9 +765,9 @@ def _matrix_bar_plot(
     mat: np.ndarray,
     z_label: str,
     ax: mplot3d.axes3d.Axes3D,
-    kets: Optional[Sequence[str]] = None,
-    title: Optional[str] = None,
-    ylim: Tuple[int, int] = (-1, 1),
+    kets: Sequence[str] | None = None,
+    title: str | None = None,
+    ylim: tuple[int, int] = (-1, 1),
     **bar3d_kwargs: Any,
 ) -> None:  # pragma: no cover
     num_rows, num_cols = mat.shape
@@ -927,8 +916,8 @@ def _single_qubit_cliffords() -> Cliffords:
         ops.SingleQubitCliffordGate.Z,
     )
 
-    c1_in_xy: List[List[ops.SingleQubitCliffordGate]] = []
-    c1_in_xz: List[List[ops.SingleQubitCliffordGate]] = []
+    c1_in_xy: list[list[ops.SingleQubitCliffordGate]] = []
+    c1_in_xz: list[list[ops.SingleQubitCliffordGate]] = []
 
     for phi_0, phi_1 in itertools.product([1.0, 0.5, -0.5], [0.0, 0.5, -0.5]):
         c1_in_xy.append([X**phi_0, Y**phi_1])
@@ -951,9 +940,9 @@ def _single_qubit_cliffords() -> Cliffords:
     for z0, x, z1 in phi_xz:
         c1_in_xz.append([Z**z0, X**x, Z**z1])
 
-    s1: List[List[ops.SingleQubitCliffordGate]] = [[X**0.0], [Y**0.5, X**0.5], [X**-0.5, Y**-0.5]]
-    s1_x: List[List[ops.SingleQubitCliffordGate]] = [[X**0.5], [X**0.5, Y**0.5, X**0.5], [Y**-0.5]]
-    s1_y: List[List[ops.SingleQubitCliffordGate]] = [
+    s1: list[list[ops.SingleQubitCliffordGate]] = [[X**0.0], [Y**0.5, X**0.5], [X**-0.5, Y**-0.5]]
+    s1_x: list[list[ops.SingleQubitCliffordGate]] = [[X**0.5], [X**0.5, Y**0.5, X**0.5], [Y**-0.5]]
+    s1_y: list[list[ops.SingleQubitCliffordGate]] = [
         [Y**0.5],
         [X**-0.5, Y**-0.5, X**0.5],
         [Y, X**0.5],

cirq/experiments/qubit_characterizations_test.py

@@ -221,7 +221,7 @@ def test_tomography_plot_raises_for_incorrect_number_of_axes():
     qubit = GridQubit(0, 0)
     circuit = circuits.Circuit(ops.X(qubit) ** 0.5)
     result = single_qubit_state_tomography(simulator, qubit, circuit, 1000)
-    with pytest.raises(TypeError):  # ax is not a List[plt.Axes]
+    with pytest.raises(TypeError):  # ax is not a list[plt.Axes]
         ax = plt.subplot()
         result.plot(ax)
     with pytest.raises(ValueError):