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

cirq/experiments/random_quantum_circuit_generation.py

@@ -17,21 +17,7 @@ from __future__ import annotations
 
 import dataclasses
 import itertools
-from typing import (
-    Any,
-    Callable,
-    cast,
-    Container,
-    Dict,
-    Iterable,
-    Iterator,
-    List,
-    Optional,
-    Sequence,
-    Tuple,
-    TYPE_CHECKING,
-    Union,
-)
+from typing import Any, Callable, cast, Container, Iterable, Iterator, Sequence, TYPE_CHECKING
 
 import numpy as np
 
@@ -43,8 +29,8 @@ if TYPE_CHECKING:
 
     import cirq
 
-QidPairT = Tuple['cirq.Qid', 'cirq.Qid']
-GridQubitPairT = Tuple['cirq.GridQubit', 'cirq.GridQubit']
+QidPairT = tuple['cirq.Qid', 'cirq.Qid']
+GridQubitPairT = tuple['cirq.GridQubit', 'cirq.GridQubit']
 
 
 @dataclasses.dataclass(frozen=True)
@@ -117,7 +103,7 @@ class GridInteractionLayer(Container[GridQubitPairT]):
         pos = a.row % 2, (a.col - self.col_offset) % 2
         return pos == (0, 0) or pos == (1, self.stagger)
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ['col_offset', 'vertical', 'stagger'])
 
     def __repr__(self) -> str:
@@ -253,7 +239,7 @@ def generate_library_of_2q_circuits(
     q1: cirq.Qid = devices.LineQubit(1),
     random_state: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
     tags: Sequence[Any] = (),
-) -> List[cirq.Circuit]:
+) -> list[cirq.Circuit]:
     """Generate a library of two-qubit Circuits.
 
     For single-qubit gates, this uses PhasedXZGates where the axis-in-XY-plane is one
@@ -309,18 +295,18 @@ class CircuitLibraryCombination:
     `get_random_combinations_for_pairs`.
     """
 
-    layer: Optional[Any]
+    layer: Any | None
     combinations: np.ndarray
-    pairs: List[QidPairT]
+    pairs: list[QidPairT]
 
 
 def _get_random_combinations(
     n_library_circuits: int,
     n_combinations: int,
     *,
-    pair_gen: Iterator[Tuple[List[QidPairT], Any]],
+    pair_gen: Iterator[tuple[list[QidPairT], Any]],
     random_state: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
-) -> List[CircuitLibraryCombination]:
+) -> list[CircuitLibraryCombination]:
     """For qubit pairs, prepare a set of combinations to efficiently sample
     parallel two-qubit XEB circuits.
 
@@ -370,7 +356,7 @@ def get_random_combinations_for_device(
     *,
     pattern: Sequence[GridInteractionLayer] = HALF_GRID_STAGGERED_PATTERN,
     random_state: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
-) -> List[CircuitLibraryCombination]:
+) -> list[CircuitLibraryCombination]:
     """For a given device, prepare a set of combinations to efficiently sample
     parallel two-qubit XEB circuits.
 
@@ -422,9 +408,9 @@ def get_random_combinations_for_device(
 def get_random_combinations_for_pairs(
     n_library_circuits: int,
     n_combinations: int,
-    all_pairs: List[List[QidPairT]],
+    all_pairs: list[list[QidPairT]],
     random_state: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
-) -> List[CircuitLibraryCombination]:
+) -> list[CircuitLibraryCombination]:
     """For an explicit nested list of pairs, prepare a set of combinations to efficiently sample
     parallel two-qubit XEB circuits.
 
@@ -463,12 +449,12 @@ def get_random_combinations_for_pairs(
     )
 
 
-def _pairs_from_moment(moment: cirq.Moment) -> List[QidPairT]:
+def _pairs_from_moment(moment: cirq.Moment) -> list[QidPairT]:
     """Helper function in `get_random_combinations_for_layer_circuit` pair generator.
 
     The moment should contain only two qubit operations, which define a list of qubit pairs.
     """
-    pairs: List[QidPairT] = []
+    pairs: list[QidPairT] = []
     for op in moment.operations:
         if len(op.qubits) != 2:
             raise ValueError("Layer circuit contains non-2-qubit operations.")
@@ -482,7 +468,7 @@ def get_random_combinations_for_layer_circuit(
     n_combinations: int,
     layer_circuit: cirq.Circuit,
     random_state: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
-) -> List[CircuitLibraryCombination]:
+) -> list[CircuitLibraryCombination]:
     """For a layer circuit, prepare a set of combinations to efficiently sample
     parallel two-qubit XEB circuits.
 
@@ -622,7 +608,7 @@ def random_rotations_between_grid_interaction_layers_circuit(
     return circuit
 
 
-def _coupled_qubit_pairs(qubits: List[cirq.GridQubit]) -> List[GridQubitPairT]:
+def _coupled_qubit_pairs(qubits: list[cirq.GridQubit]) -> list[GridQubitPairT]:
     pairs = []
     qubit_set = set(qubits)
     for qubit in qubits:
@@ -661,14 +647,14 @@ class _RandomSingleQubitLayerFactory:
 
 
 class _FixedSingleQubitLayerFactory:
-    def __init__(self, fixed_single_qubit_layer: Dict[cirq.Qid, cirq.Gate]) -> None:
+    def __init__(self, fixed_single_qubit_layer: dict[cirq.Qid, cirq.Gate]) -> None:
         self.fixed_single_qubit_layer = fixed_single_qubit_layer
 
     def new_layer(self, previous_single_qubit_layer: cirq.Moment) -> cirq.Moment:
         return circuits.Moment(v.on(q) for q, v in self.fixed_single_qubit_layer.items())
 
 
-_SingleQubitLayerFactory = Union[_FixedSingleQubitLayerFactory, _RandomSingleQubitLayerFactory]
+_SingleQubitLayerFactory = _FixedSingleQubitLayerFactory | _RandomSingleQubitLayerFactory
 
 
 def _single_qubit_gates_arg_to_factory(
@@ -687,7 +673,7 @@ def _single_qubit_gates_arg_to_factory(
 
 
 def _two_qubit_layer(
-    coupled_qubit_pairs: List[GridQubitPairT],
+    coupled_qubit_pairs: list[GridQubitPairT],
     two_qubit_op_factory: Callable[
         [cirq.GridQubit, cirq.GridQubit, np.random.RandomState], cirq.OP_TREE
     ],

cirq/experiments/random_quantum_circuit_generation_test.py

@@ -15,7 +15,7 @@
 from __future__ import annotations
 
 import itertools
-from typing import Callable, cast, Dict, Iterable, List, Optional, Sequence, Set, Tuple
+from typing import Callable, cast, Iterable, Sequence
 
 import networkx as nx
 import numpy as np
@@ -35,7 +35,7 @@ from cirq.experiments.random_quantum_circuit_generation import (
     random_rotations_between_two_qubit_circuit,
 )
 
-SINGLE_QUBIT_LAYER = Dict[cirq.GridQubit, Optional[cirq.Gate]]
+SINGLE_QUBIT_LAYER = dict[cirq.GridQubit, cirq.Gate | None]
 
 
 def test_random_rotation_between_two_qubit_circuit():
@@ -404,7 +404,7 @@ def test_grid_interaction_layer_repr():
 
 
 def _validate_single_qubit_layers(
-    qubits: Set[cirq.GridQubit], moments: Sequence[cirq.Moment], non_repeating_layers: bool = True
+    qubits: set[cirq.GridQubit], moments: Sequence[cirq.Moment], non_repeating_layers: bool = True
 ) -> None:
     previous_single_qubit_gates: SINGLE_QUBIT_LAYER = {q: None for q in qubits}
 
@@ -422,7 +422,7 @@ def _validate_single_qubit_layers(
 
 
 def _validate_two_qubit_layers(
-    qubits: Set[cirq.GridQubit],
+    qubits: set[cirq.GridQubit],
     moments: Sequence[cirq.Moment],
     pattern: Sequence[cirq.experiments.GridInteractionLayer],
 ) -> None:
@@ -447,8 +447,8 @@ def _validate_two_qubit_layers(
 
 
 def _coupled_qubit_pairs(
-    qubits: Set[cirq.GridQubit],
-) -> List[Tuple[cirq.GridQubit, cirq.GridQubit]]:
+    qubits: set[cirq.GridQubit],
+) -> list[tuple[cirq.GridQubit, cirq.GridQubit]]:
     pairs = []
     for qubit in qubits:
 

cirq/experiments/readout_confusion_matrix.py

@@ -17,7 +17,7 @@
 from __future__ import annotations
 
 import time
-from typing import Any, cast, Dict, List, Optional, Sequence, Tuple, TYPE_CHECKING, Union
+from typing import Any, cast, Sequence, TYPE_CHECKING
 
 import numpy as np
 import scipy.optimize
@@ -61,8 +61,8 @@ class TensoredConfusionMatrices:
 
     def __init__(
         self,
-        confusion_matrices: Union[np.ndarray, Sequence[np.ndarray]],
-        measure_qubits: Union[Sequence[cirq.Qid], Sequence[Sequence[cirq.Qid]]],
+        confusion_matrices: np.ndarray | Sequence[np.ndarray],
+        measure_qubits: Sequence[cirq.Qid] | Sequence[Sequence[cirq.Qid]],
         *,
         repetitions: int,
         timestamp: float,
@@ -114,7 +114,7 @@ class TensoredConfusionMatrices:
         self._measure_qubits = tuple(tuple(q) for q in measure_qubits)
         self._qubits = tuple(sorted(set(q for ql in measure_qubits for q in ql)))
         self._qubits_to_idx = {q: i for i, q in enumerate(self._qubits)}
-        self._cache: Dict[Tuple[cirq.Qid, ...], np.ndarray] = {}
+        self._cache: dict[tuple[cirq.Qid, ...], np.ndarray] = {}
         if sum(len(q) for q in self._measure_qubits) != len(self._qubits):
             raise ValueError(f"Repeated qubits not allowed in measure_qubits: {measure_qubits}.")
 
@@ -157,27 +157,27 @@ class TensoredConfusionMatrices:
         return self._timestamp
 
     @property
-    def confusion_matrices(self) -> Tuple[np.ndarray, ...]:
+    def confusion_matrices(self) -> tuple[np.ndarray, ...]:
         """List of confusion matrices corresponding to `measure_qubits` qubit pattern."""
         return self._confusion_matrices
 
     @property
-    def measure_qubits(self) -> Tuple[Tuple[cirq.Qid, ...], ...]:
+    def measure_qubits(self) -> tuple[tuple[cirq.Qid, ...], ...]:
         """Calibrated qubit pattern for which individual confusion matrices were computed."""
         return self._measure_qubits
 
     @property
-    def qubits(self) -> Tuple[cirq.Qid, ...]:
+    def qubits(self) -> tuple[cirq.Qid, ...]:
         """Sorted list of all calibrated qubits."""
         return self._qubits
 
-    def _get_vars(self, qubit_pattern: Sequence[cirq.Qid]) -> List[int]:
+    def _get_vars(self, qubit_pattern: Sequence[cirq.Qid]) -> list[int]:
         in_vars = [2 * self._qubits_to_idx[q] for q in qubit_pattern]
         out_vars = [2 * self._qubits_to_idx[q] + 1 for q in qubit_pattern]
         return in_vars + out_vars
 
     def _confusion_matrix(self, qubits: Sequence[cirq.Qid]) -> np.ndarray:
-        ein_input: List[np.ndarray | List[int]] = []
+        ein_input: list[np.ndarray | list[int]] = []
         for qs, cm in zip(self.measure_qubits, self.confusion_matrices):
             ein_input.extend([cm.reshape((2, 2) * len(qs)), self._get_vars(qs)])
         ein_out = self._get_vars(qubits)
@@ -185,7 +185,7 @@ class TensoredConfusionMatrices:
         ret = np.einsum(*ein_input, ein_out).reshape((2 ** len(qubits),) * 2)
         return ret / ret.sum(axis=1)
 
-    def confusion_matrix(self, qubits: Optional[Sequence[cirq.Qid]] = None) -> np.ndarray:
+    def confusion_matrix(self, qubits: Sequence[cirq.Qid] | None = None) -> np.ndarray:
         """Returns a single confusion matrix constructed for the given set of qubits.
 
         The single `2 ** len(qubits) x 2 ** len(qubits)` confusion matrix is constructed
@@ -213,7 +213,7 @@ class TensoredConfusionMatrices:
             self._cache[key] = self._confusion_matrix(qubits)
         return self._cache[key]
 
-    def correction_matrix(self, qubits: Optional[Sequence[cirq.Qid]] = None) -> np.ndarray:
+    def correction_matrix(self, qubits: Sequence[cirq.Qid] | None = None) -> np.ndarray:
         """Returns a single correction matrix constructed for the given set of qubits.
 
         A correction matrix is the inverse of confusion matrix and can be used to apply corrections
@@ -242,7 +242,7 @@ class TensoredConfusionMatrices:
     def apply(
         self,
         result: np.ndarray,
-        qubits: Optional[Sequence[cirq.Qid]] = None,
+        qubits: Sequence[cirq.Qid] | None = None,
         *,
         method='least_squares',
     ) -> np.ndarray:
@@ -375,7 +375,7 @@ class TensoredConfusionMatrices:
             f")"
         )
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return {
             'confusion_matrices': self.confusion_matrices,
             'measure_qubits': self.measure_qubits,
@@ -426,7 +426,7 @@ class TensoredConfusionMatrices:
 
 def measure_confusion_matrix(
     sampler: cirq.Sampler,
-    qubits: Union[Sequence[cirq.Qid], Sequence[Sequence[cirq.Qid]]],
+    qubits: Sequence[cirq.Qid] | Sequence[Sequence[cirq.Qid]],
     repetitions: int = 1000,
 ) -> TensoredConfusionMatrices:
     """Prepares `TensoredConfusionMatrices` for the n qubits in the input.

cirq/experiments/single_qubit_readout_calibration.py

@@ -18,7 +18,7 @@ from __future__ import annotations
 
 import dataclasses
 import time
-from typing import Any, cast, Dict, Iterable, List, Optional, TYPE_CHECKING
+from typing import Any, cast, Iterable, TYPE_CHECKING
 
 import matplotlib.pyplot as plt
 import numpy as np
@@ -47,12 +47,12 @@ class SingleQubitReadoutCalibrationResult:
         timestamp: The time the data was taken, in seconds since the epoch.
     """
 
-    zero_state_errors: Dict[cirq.Qid, float]
-    one_state_errors: Dict[cirq.Qid, float]
+    zero_state_errors: dict[cirq.Qid, float]
+    one_state_errors: dict[cirq.Qid, float]
     repetitions: int
     timestamp: float
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return {
             'zero_state_errors': list(self.zero_state_errors.items()),
             'one_state_errors': list(self.one_state_errors.items()),
@@ -62,7 +62,7 @@ class SingleQubitReadoutCalibrationResult:
 
     def plot_heatmap(
         self,
-        axs: Optional[tuple[plt.Axes, plt.Axes]] = None,
+        axs: tuple[plt.Axes, plt.Axes] | None = None,
         annotation_format: str = '0.1%',
         **plot_kwargs: Any,
     ) -> tuple[plt.Axes, plt.Axes]:
@@ -110,16 +110,16 @@ class SingleQubitReadoutCalibrationResult:
 
     def plot_integrated_histogram(
         self,
-        ax: Optional[plt.Axes] = None,
+        ax: plt.Axes | None = None,
         cdf_on_x: bool = False,
         axis_label: str = 'Readout error rate',
         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 readout errors using cirq.integrated_histogram().
@@ -238,8 +238,8 @@ def estimate_parallel_single_qubit_readout_errors(
     qubits: Iterable[cirq.Qid],
     trials: int = 20,
     repetitions: int = 1000,
-    trials_per_batch: Optional[int] = None,
-    bit_strings: Optional[np.ndarray] = None,
+    trials_per_batch: int | None = None,
+    bit_strings: np.ndarray | None = None,
 ) -> SingleQubitReadoutCalibrationResult:
     """Estimate single qubit readout error using parallel operations.
 
@@ -300,7 +300,7 @@ def estimate_parallel_single_qubit_readout_errors(
     if trials_per_batch <= 0:
         raise ValueError("Must provide non-zero trials_per_batch for readout calibration.")
 
-    all_sweeps: List[study.Sweepable] = []
+    all_sweeps: list[study.Sweepable] = []
     num_batches = (trials + trials_per_batch - 1) // trials_per_batch
 
     # Initialize circuits

cirq/experiments/t2_decay_experiment.py

@@ -15,7 +15,7 @@
 from __future__ import annotations
 
 import enum
-from typing import Any, List, Optional, TYPE_CHECKING, Union
+from typing import Any, TYPE_CHECKING
 
 import pandas as pd
 import sympy
@@ -46,9 +46,9 @@ def t2_decay(
     max_delay: cirq.DURATION_LIKE,
     min_delay: cirq.DURATION_LIKE = None,
     repetitions: int = 1000,
-    delay_sweep: Optional[study.Sweep] = None,
-    num_pulses: Optional[List[int]] = None,
-) -> Union[cirq.experiments.T2DecayResult, List[cirq.experiments.T2DecayResult]]:
+    delay_sweep: study.Sweep | None = None,
+    num_pulses: list[int] | None = None,
+) -> cirq.experiments.T2DecayResult | list[cirq.experiments.T2DecayResult]:
     """Runs a t2 transverse relaxation experiment.
 
     Initializes a qubit into a superposition state, evolves the system using
@@ -259,7 +259,7 @@ def _cpmg_circuit(qubit: cirq.Qid, delay_var: sympy.Symbol, max_pulses: int) ->
     return circuit
 
 
-def _cpmg_sweep(num_pulses: List[int]):
+def _cpmg_sweep(num_pulses: list[int]):
     """Returns a sweep for a circuit created by _cpmg_circuit.
 
     The circuit in _cpmg_circuit parameterizes the pulses, so this function
@@ -354,7 +354,7 @@ class T2DecayResult:
         """
         return self._expectation_pauli_y
 
-    def plot_expectations(self, ax: Optional[plt.Axes] = None, **plot_kwargs: Any) -> plt.Axes:
+    def plot_expectations(self, ax: plt.Axes | None = None, **plot_kwargs: Any) -> plt.Axes:
         """Plots the expectation values of Pauli operators versus delay time.
 
         Args:
@@ -395,7 +395,7 @@ class T2DecayResult:
             fig.show()
         return ax
 
-    def plot_bloch_vector(self, ax: Optional[plt.Axes] = None, **plot_kwargs: Any) -> plt.Axes:
+    def plot_bloch_vector(self, ax: plt.Axes | None = None, **plot_kwargs: Any) -> plt.Axes:
         """Plots the estimated length of the Bloch vector versus time.
 
         This plot estimates the Bloch Vector by squaring the Pauli expectation

cirq/experiments/two_qubit_xeb.py

@@ -20,7 +20,7 @@ import functools
 import itertools
 from dataclasses import dataclass
 from types import MappingProxyType
-from typing import Any, cast, Dict, Mapping, Optional, Sequence, Tuple, TYPE_CHECKING
+from typing import Any, cast, Mapping, Sequence, TYPE_CHECKING
 
 import networkx as nx
 import numpy as np
@@ -49,7 +49,7 @@ if TYPE_CHECKING:
     import cirq
 
 
-def _grid_qubits_for_sampler(sampler: cirq.Sampler) -> Optional[Sequence[cirq.GridQubit]]:
+def _grid_qubits_for_sampler(sampler: cirq.Sampler) -> Sequence[cirq.GridQubit] | None:
     if hasattr(sampler, 'processor'):
         device = sampler.processor.get_device()
         return sorted(device.metadata.qubit_set)
@@ -62,9 +62,9 @@ def _manhattan_distance(qubit1: cirq.GridQubit, qubit2: cirq.GridQubit) -> int:
 
 def qubits_and_pairs(
     sampler: cirq.Sampler,
-    qubits: Optional[Sequence[cirq.GridQubit]] = None,
-    pairs: Optional[Sequence[tuple[cirq.GridQubit, cirq.GridQubit]]] = None,
-) -> Tuple[Sequence[cirq.GridQubit], Sequence[tuple[cirq.GridQubit, cirq.GridQubit]]]:
+    qubits: Sequence[cirq.GridQubit] | None = None,
+    pairs: Sequence[tuple[cirq.GridQubit, cirq.GridQubit]] | None = None,
+) -> tuple[Sequence[cirq.GridQubit], Sequence[tuple[cirq.GridQubit, cirq.GridQubit]]]:
     """Extract qubits and pairs from sampler.
 
 
@@ -107,7 +107,7 @@ class TwoQubitXEBResult:
     fidelities: pd.DataFrame
 
     @functools.cached_property
-    def _qubit_pair_map(self) -> Dict[Tuple[cirq.GridQubit, cirq.GridQubit], int]:
+    def _qubit_pair_map(self) -> dict[tuple[cirq.GridQubit, cirq.GridQubit], int]:
         if isinstance(self.fidelities.index[0][0], ops.Qid):
             return {
                 (min(q0, q1), max(q0, q1)): i for i, (q0, q1) in enumerate(self.fidelities.index)
@@ -118,10 +118,10 @@ class TwoQubitXEBResult:
         }
 
     @functools.cached_property
-    def all_qubit_pairs(self) -> Tuple[Tuple[cirq.GridQubit, cirq.GridQubit], ...]:
+    def all_qubit_pairs(self) -> tuple[tuple[cirq.GridQubit, cirq.GridQubit], ...]:
         return tuple(sorted(self._qubit_pair_map.keys()))
 
-    def plot_heatmap(self, ax: Optional[plt.Axes] = None, **plot_kwargs) -> plt.Axes:
+    def plot_heatmap(self, ax: plt.Axes | None = None, **plot_kwargs) -> plt.Axes:
         """plot the heatmap of XEB errors.
 
         Args:
@@ -135,7 +135,7 @@ class TwoQubitXEBResult:
         show_plot = not ax
         if not isinstance(ax, plt.Axes):
             fig, ax = plt.subplots(1, 1, figsize=(8, 8))
-        heatmap_data: Dict[Tuple[cirq.GridQubit, ...], float] = {
+        heatmap_data: dict[tuple[cirq.GridQubit, ...], float] = {
             pair: self.xeb_error(*pair) for pair in self.all_qubit_pairs
         }
 
@@ -147,7 +147,7 @@ class TwoQubitXEBResult:
         return ax
 
     def plot_fitted_exponential(
-        self, q0: cirq.GridQubit, q1: cirq.GridQubit, ax: Optional[plt.Axes] = None, **plot_kwargs
+        self, q0: cirq.GridQubit, q1: cirq.GridQubit, ax: plt.Axes | None = None, **plot_kwargs
     ) -> plt.Axes:
         """plot the fitted model to for xeb error of a qubit pair.
 
@@ -199,11 +199,11 @@ class TwoQubitXEBResult:
         """Return the XEB error of a qubit pair."""
         return 1 - self.xeb_fidelity(q0, q1)
 
-    def all_errors(self) -> Dict[Tuple[cirq.GridQubit, cirq.GridQubit], float]:
+    def all_errors(self) -> dict[tuple[cirq.GridQubit, cirq.GridQubit], float]:
         """Return the XEB error of all qubit pairs."""
         return {(q0, q1): self.xeb_error(q0, q1) for q0, q1 in self.all_qubit_pairs}
 
-    def plot_histogram(self, ax: Optional[plt.Axes] = None, **plot_kwargs) -> plt.Axes:
+    def plot_histogram(self, ax: plt.Axes | None = None, **plot_kwargs) -> plt.Axes:
         """plot a histogram of all xeb errors.
 
         Args:
@@ -223,7 +223,7 @@ class TwoQubitXEBResult:
         return ax
 
     @cached_method
-    def pauli_error(self) -> Dict[Tuple[cirq.GridQubit, cirq.GridQubit], float]:
+    def pauli_error(self) -> dict[tuple[cirq.GridQubit, cirq.GridQubit], float]:
         """Return the Pauli error of all qubit pairs."""
         return {
             pair: noise_utils.decay_constant_to_pauli_error(
@@ -246,7 +246,7 @@ class InferredXEBResult:
     xeb_result: TwoQubitXEBResult
 
     @property
-    def all_qubit_pairs(self) -> Sequence[Tuple[cirq.GridQubit, cirq.GridQubit]]:
+    def all_qubit_pairs(self) -> Sequence[tuple[cirq.GridQubit, cirq.GridQubit]]:
         return self.xeb_result.all_qubit_pairs
 
     @cached_method
@@ -255,12 +255,12 @@ class InferredXEBResult:
         return self.rb_result.pauli_error()
 
     @cached_method
-    def two_qubit_pauli_error(self) -> Mapping[Tuple[cirq.GridQubit, cirq.GridQubit], float]:
+    def two_qubit_pauli_error(self) -> Mapping[tuple[cirq.GridQubit, cirq.GridQubit], float]:
         """Return the two-qubit Pauli error for all pairs."""
         return MappingProxyType(self.xeb_result.pauli_error())
 
     @cached_method
-    def inferred_pauli_error(self) -> Mapping[Tuple[cirq.GridQubit, cirq.GridQubit], float]:
+    def inferred_pauli_error(self) -> Mapping[tuple[cirq.GridQubit, cirq.GridQubit], float]:
         """Return the inferred Pauli error for all pairs."""
         single_q_paulis = self.rb_result.pauli_error()
         xeb = self.xeb_result.pauli_error()
@@ -272,7 +272,7 @@ class InferredXEBResult:
         return MappingProxyType({pair: _pauli_error(*pair) for pair in self.all_qubit_pairs})
 
     @cached_method
-    def inferred_decay_constant(self) -> Mapping[Tuple[cirq.GridQubit, cirq.GridQubit], float]:
+    def inferred_decay_constant(self) -> Mapping[tuple[cirq.GridQubit, cirq.GridQubit], float]:
         """Return the inferred decay constant for all pairs."""
         return MappingProxyType(
             {
@@ -282,7 +282,7 @@ class InferredXEBResult:
         )
 
     @cached_method
-    def inferred_xeb_error(self) -> Mapping[Tuple[cirq.GridQubit, cirq.GridQubit], float]:
+    def inferred_xeb_error(self) -> Mapping[tuple[cirq.GridQubit, cirq.GridQubit], float]:
         """Return the inferred XEB error for all pairs."""
         return MappingProxyType(
             {
@@ -293,7 +293,7 @@ class InferredXEBResult:
 
     def _target_errors(
         self, target_error: str
-    ) -> Mapping[Tuple[cirq.GridQubit, cirq.GridQubit], float]:
+    ) -> Mapping[tuple[cirq.GridQubit, cirq.GridQubit], float]:
         """Returns requested error.
 
         The requested error must be one of 'pauli', 'decay_constant', or 'xeb'.
@@ -315,7 +315,7 @@ class InferredXEBResult:
         return error_funcs[target_error]()
 
     def plot_heatmap(
-        self, target_error: str = 'pauli', ax: Optional[plt.Axes] = None, **plot_kwargs
+        self, target_error: str = 'pauli', ax: plt.Axes | None = None, **plot_kwargs
     ) -> plt.Axes:
         """plot the heatmap of the target errors.
 
@@ -329,7 +329,7 @@ class InferredXEBResult:
         if not isinstance(ax, plt.Axes):
             fig, ax = plt.subplots(1, 1, figsize=(8, 8))
         heatmap_data = cast(
-            Mapping[Tuple['cirq.GridQubit', ...], float], self._target_errors(target_error)
+            Mapping[tuple['cirq.GridQubit', ...], float], self._target_errors(target_error)
         )
 
         name = f'{target_error} error' if target_error != 'decay_constant' else 'decay constant'
@@ -343,7 +343,7 @@ class InferredXEBResult:
     def plot_histogram(
         self,
         target_error: str = 'pauli',
-        ax: Optional[plt.Axes] = None,
+        ax: plt.Axes | None = None,
         kind: str = 'two_qubit',
         **plot_kwargs,
     ) -> plt.Axes:
@@ -398,20 +398,20 @@ class InferredXEBResult:
 
 def parallel_xeb_workflow(
     sampler: cirq.Sampler,
-    qubits: Optional[Sequence[cirq.GridQubit]] = None,
+    qubits: Sequence[cirq.GridQubit] | None = None,
     entangling_gate: cirq.Gate = ops.CZ,
     n_repetitions: int = 10**4,
     n_combinations: int = 10,
     n_circuits: int = 20,
     cycle_depths: Sequence[int] = (5, 25, 50, 100, 200, 300),
     random_state: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
-    ax: Optional[plt.Axes] = None,
-    pairs: Optional[Sequence[tuple[cirq.GridQubit, cirq.GridQubit]]] = None,
-    pool: Optional[multiprocessing.pool.Pool] = None,
+    ax: plt.Axes | None = None,
+    pairs: Sequence[tuple[cirq.GridQubit, cirq.GridQubit]] | None = None,
+    pool: multiprocessing.pool.Pool | None = None,
     batch_size: int = 9,
     tags: Sequence[Any] = (),
     **plot_kwargs,
-) -> Tuple[pd.DataFrame, Sequence[cirq.Circuit], pd.DataFrame]:
+) -> tuple[pd.DataFrame, Sequence[cirq.Circuit], pd.DataFrame]:
     """A utility method that runs the full XEB workflow.
 
     Args:
@@ -488,15 +488,15 @@ def parallel_xeb_workflow(
 
 def parallel_two_qubit_xeb(
     sampler: cirq.Sampler,
-    qubits: Optional[Sequence[cirq.GridQubit]] = None,
+    qubits: Sequence[cirq.GridQubit] | None = None,
     entangling_gate: cirq.Gate = ops.CZ,
     n_repetitions: int = 10**4,
     n_combinations: int = 10,
     n_circuits: int = 20,
     cycle_depths: Sequence[int] = (5, 25, 50, 100, 200, 300),
     random_state: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
-    ax: Optional[plt.Axes] = None,
-    pairs: Optional[Sequence[tuple[cirq.GridQubit, cirq.GridQubit]]] = None,
+    ax: plt.Axes | None = None,
+    pairs: Sequence[tuple[cirq.GridQubit, cirq.GridQubit]] | None = None,
     batch_size: int = 9,
     tags: Sequence[Any] = (),
     **plot_kwargs,
@@ -545,7 +545,7 @@ def parallel_two_qubit_xeb(
 
 def run_rb_and_xeb(
     sampler: cirq.Sampler,
-    qubits: Optional[Sequence[cirq.GridQubit]] = None,
+    qubits: Sequence[cirq.GridQubit] | None = None,
     repetitions: int = 10**3,
     num_circuits: int = 20,
     num_clifford_range: Sequence[int] = tuple(
@@ -555,7 +555,7 @@ def run_rb_and_xeb(
     depths_xeb: Sequence[int] = (5, 25, 50, 100, 200, 300),
     xeb_combinations: int = 10,
     random_state: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
-    pairs: Optional[Sequence[tuple[cirq.GridQubit, cirq.GridQubit]]] = None,
+    pairs: Sequence[tuple[cirq.GridQubit, cirq.GridQubit]] | None = None,
     batch_size: int = 9,
     tags: Sequence[Any] = (),
 ) -> InferredXEBResult: