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

cirq/experiments/two_qubit_xeb_test.py

@@ -18,7 +18,7 @@ from __future__ import annotations
 
 import io
 import itertools
-from typing import Dict, Optional, Sequence
+from typing import Sequence
 
 import matplotlib.pyplot as plt
 import networkx as nx
@@ -90,7 +90,7 @@ def test_parallel_two_qubit_xeb_simulator_without_processor_fails():
         ),
     ],
 )
-def test_parallel_two_qubit_xeb(sampler: cirq.Sampler, qubits: Optional[Sequence[cirq.GridQubit]]):
+def test_parallel_two_qubit_xeb(sampler: cirq.Sampler, qubits: Sequence[cirq.GridQubit] | None):
     res = cirq.experiments.parallel_two_qubit_xeb(
         sampler=sampler,
         qubits=qubits,
@@ -162,7 +162,7 @@ def test_pauli_error(q0: cirq.GridQubit, q1: cirq.GridQubit, pauli: float):
 
 
 class MockParallelRandomizedBenchmarkingResult(ParallelRandomizedBenchmarkingResult):
-    def pauli_error(self) -> Dict[cirq.Qid, float]:
+    def pauli_error(self) -> dict[cirq.Qid, float]:
         return {
             cirq.GridQubit(4, 4): 0.01,
             cirq.GridQubit(5, 4): 0.02,
@@ -294,8 +294,8 @@ def test_inferred_plots(ax, target_error, kind):
 )
 def test_run_rb_and_xeb(
     sampler: cirq.Sampler,
-    qubits: Optional[Sequence[cirq.GridQubit]],
-    pairs: Optional[Sequence[tuple[cirq.GridQubit, cirq.GridQubit]]],
+    qubits: Sequence[cirq.GridQubit] | None,
+    pairs: Sequence[tuple[cirq.GridQubit, cirq.GridQubit]] | None,
 ):
     res = cirq.experiments.run_rb_and_xeb(
         sampler=sampler,

cirq/experiments/xeb_fitting.py

@@ -18,7 +18,7 @@ from __future__ import annotations
 
 import dataclasses
 from abc import ABC, abstractmethod
-from typing import Dict, Iterable, List, Optional, Sequence, Tuple, TYPE_CHECKING
+from typing import Iterable, Sequence, TYPE_CHECKING
 
 import numpy as np
 import pandas as pd
@@ -46,9 +46,9 @@ THETA_SYMBOL, ZETA_SYMBOL, CHI_SYMBOL, GAMMA_SYMBOL, PHI_SYMBOL = sympy.symbols(
 def benchmark_2q_xeb_fidelities(
     sampled_df: pd.DataFrame,
     circuits: Sequence[cirq.Circuit],
-    cycle_depths: Optional[Sequence[int]] = None,
+    cycle_depths: Sequence[int] | None = None,
     param_resolver: cirq.ParamResolverOrSimilarType = None,
-    pool: Optional[multiprocessing.pool.Pool] = None,
+    pool: multiprocessing.pool.Pool | None = None,
 ) -> pd.DataFrame:
     """Simulate and benchmark two-qubit XEB circuits.
 
@@ -158,11 +158,11 @@ class XEBCharacterizationOptions(ABC):
     @abstractmethod
     def get_initial_simplex_and_names(
         self, initial_simplex_step_size: float = 0.1
-    ) -> Tuple[np.ndarray, List[str]]:
+    ) -> tuple[np.ndarray, list[str]]:
         """Return an initial Nelder-Mead simplex and the names for each parameter."""
 
 
-def _try_defaults_from_unitary(gate: cirq.Gate) -> Optional[Dict[str, cirq.TParamVal]]:
+def _try_defaults_from_unitary(gate: cirq.Gate) -> dict[str, cirq.TParamVal] | None:
     r"""Try to figure out the PhasedFSim angles from the unitary of the gate.
 
     The unitary of a PhasedFSimGate has the form:
@@ -225,10 +225,10 @@ def _try_defaults_from_unitary(gate: cirq.Gate) -> Optional[Dict[str, cirq.TPara
     return None
 
 
-def phased_fsim_angles_from_gate(gate: cirq.Gate) -> Dict[str, cirq.TParamVal]:
+def phased_fsim_angles_from_gate(gate: cirq.Gate) -> dict[str, cirq.TParamVal]:
     """For a given gate, return a dictionary mapping '{angle}_default' to its noiseless value
     for the five PhasedFSim angles."""
-    defaults: Dict[str, cirq.TParamVal] = {
+    defaults: dict[str, cirq.TParamVal] = {
         'theta_default': 0.0,
         'zeta_default': 0.0,
         'chi_default': 0.0,
@@ -288,13 +288,13 @@ class XEBPhasedFSimCharacterizationOptions(XEBCharacterizationOptions):
     characterize_gamma: bool = True
     characterize_phi: bool = True
 
-    theta_default: Optional[float] = None
-    zeta_default: Optional[float] = None
-    chi_default: Optional[float] = None
-    gamma_default: Optional[float] = None
-    phi_default: Optional[float] = None
+    theta_default: float | None = None
+    zeta_default: float | None = None
+    chi_default: float | None = None
+    gamma_default: float | None = None
+    phi_default: float | None = None
 
-    def _iter_angles(self) -> Iterable[Tuple[bool, Optional[float], sympy.Symbol]]:
+    def _iter_angles(self) -> Iterable[tuple[bool, float | None, sympy.Symbol]]:
         yield from (
             (self.characterize_theta, self.theta_default, THETA_SYMBOL),
             (self.characterize_zeta, self.zeta_default, ZETA_SYMBOL),
@@ -303,7 +303,7 @@ class XEBPhasedFSimCharacterizationOptions(XEBCharacterizationOptions):
             (self.characterize_phi, self.phi_default, PHI_SYMBOL),
         )
 
-    def _iter_angles_for_characterization(self) -> Iterable[Tuple[Optional[float], sympy.Symbol]]:
+    def _iter_angles_for_characterization(self) -> Iterable[tuple[float | None, sympy.Symbol]]:
         yield from (
             (default, symbol)
             for characterize, default, symbol in self._iter_angles()
@@ -312,7 +312,7 @@ class XEBPhasedFSimCharacterizationOptions(XEBCharacterizationOptions):
 
     def get_initial_simplex_and_names(
         self, initial_simplex_step_size: float = 0.1
-    ) -> Tuple[np.ndarray, List[str]]:
+    ) -> tuple[np.ndarray, list[str]]:
         """Get an initial simplex and parameter names for the optimization implied by these options.
 
         The initial simplex initiates the Nelder-Mead optimization parameter. We
@@ -403,7 +403,7 @@ def SqrtISwapXEBOptions(*args, **kwargs):
 def parameterize_circuit(
     circuit: cirq.Circuit,
     options: XEBCharacterizationOptions,
-    target_gatefamily: Optional[ops.GateFamily] = None,
+    target_gatefamily: ops.GateFamily | None = None,
 ) -> cirq.Circuit:
     """Parameterize PhasedFSim-like gates in a given circuit according to
     `phased_fsim_options`.
@@ -421,7 +421,7 @@ def parameterize_circuit(
     )
 
 
-QPair_T = Tuple['cirq.Qid', 'cirq.Qid']
+QPair_T = tuple['cirq.Qid', 'cirq.Qid']
 
 
 @dataclasses.dataclass(frozen=True)
@@ -436,21 +436,21 @@ class XEBCharacterizationResult:
             fitting the characterization.
     """
 
-    optimization_results: Dict[QPair_T, scipy.optimize.OptimizeResult]
-    final_params: Dict[QPair_T, Dict[str, float]]
+    optimization_results: dict[QPair_T, scipy.optimize.OptimizeResult]
+    final_params: dict[QPair_T, dict[str, float]]
     fidelities_df: pd.DataFrame
 
 
 def characterize_phased_fsim_parameters_with_xeb(
     sampled_df: pd.DataFrame,
-    parameterized_circuits: List[cirq.Circuit],
+    parameterized_circuits: list[cirq.Circuit],
     cycle_depths: Sequence[int],
     options: XEBCharacterizationOptions,
     initial_simplex_step_size: float = 0.1,
     xatol: float = 1e-3,
     fatol: float = 1e-3,
     verbose: bool = True,
-    pool: Optional[multiprocessing.pool.Pool] = None,
+    pool: multiprocessing.pool.Pool | None = None,
 ) -> XEBCharacterizationResult:
     """Run a classical optimization to fit phased fsim parameters to experimental data, and
     thereby characterize PhasedFSim-like gates.
@@ -516,7 +516,7 @@ class _CharacterizePhasedFsimParametersWithXebClosure:
     """A closure object to wrap `characterize_phased_fsim_parameters_with_xeb` for use in
     multiprocessing."""
 
-    parameterized_circuits: List[cirq.Circuit]
+    parameterized_circuits: list[cirq.Circuit]
     cycle_depths: Sequence[int]
     options: XEBCharacterizationOptions
     initial_simplex_step_size: float = 0.1
@@ -539,13 +539,13 @@ class _CharacterizePhasedFsimParametersWithXebClosure:
 
 def characterize_phased_fsim_parameters_with_xeb_by_pair(
     sampled_df: pd.DataFrame,
-    parameterized_circuits: List[cirq.Circuit],
+    parameterized_circuits: list[cirq.Circuit],
     cycle_depths: Sequence[int],
     options: XEBCharacterizationOptions,
     initial_simplex_step_size: float = 0.1,
     xatol: float = 1e-3,
     fatol: float = 1e-3,
-    pool: Optional[multiprocessing.pool.Pool] = None,
+    pool: multiprocessing.pool.Pool | None = None,
 ) -> XEBCharacterizationResult:
     """Run a classical optimization to fit phased fsim parameters to experimental data, and
     thereby characterize PhasedFSim-like gates grouped by pairs.
@@ -618,7 +618,7 @@ def exponential_decay(cycle_depths: np.ndarray, a: float, layer_fid: float) -> n
 
 def _fit_exponential_decay(
     cycle_depths: np.ndarray, fidelities: np.ndarray
-) -> Tuple[float, float, float, float]:
+) -> tuple[float, float, float, float]:
     """Fit an exponential model fidelity = a * layer_fid**x using nonlinear least squares.
 
     This uses `exponential_decay` as the function to fit with parameters `a` and `layer_fid`.

cirq/experiments/xeb_sampling.py

@@ -20,18 +20,7 @@ import os
 import time
 import uuid
 from dataclasses import dataclass
-from typing import (
-    Any,
-    Callable,
-    ContextManager,
-    Dict,
-    List,
-    Optional,
-    Sequence,
-    Set,
-    Tuple,
-    TYPE_CHECKING,
-)
+from typing import Any, Callable, ContextManager, Sequence, TYPE_CHECKING
 
 import numpy as np
 import pandas as pd
@@ -57,7 +46,7 @@ class _Sample2qXEBTask:
     layer_i: int
     combination_i: int
     prepared_circuit: cirq.AbstractCircuit
-    combination: List[int]
+    combination: list[int]
 
 
 class _SampleInBatches:
@@ -65,7 +54,7 @@ class _SampleInBatches:
         self,
         sampler: cirq.Sampler,
         repetitions: int,
-        combinations_by_layer: List[CircuitLibraryCombination],
+        combinations_by_layer: list[CircuitLibraryCombination],
     ):
         """This closure will execute a list of `tasks` with one call to
         `run_batch` on the provided sampler for a given number of repetitions.
@@ -80,7 +69,7 @@ class _SampleInBatches:
         self.repetitions = repetitions
         self.combinations_by_layer = combinations_by_layer
 
-    def __call__(self, tasks: List[_Sample2qXEBTask]) -> List[Dict[str, Any]]:
+    def __call__(self, tasks: list[_Sample2qXEBTask]) -> list[dict[str, Any]]:
         prepared_circuits = [task.prepared_circuit for task in tasks]
         results = self.sampler.run_batch(prepared_circuits, repetitions=self.repetitions)
         timestamp = time.time()
@@ -113,7 +102,7 @@ class _SampleInBatches:
 
 def _verify_and_get_two_qubits_from_circuits(circuits: Sequence[cirq.Circuit]):
     """Make sure each of the provided circuits uses the same two qubits and return them."""
-    all_qubits_set: Set[cirq.Qid] = set()
+    all_qubits_set: set[cirq.Qid] = set()
     all_qubits_set = all_qubits_set.union(*(circuit.all_qubits() for circuit in circuits))
     all_qubits_list = sorted(all_qubits_set)
     if len(all_qubits_list) != 2:
@@ -170,15 +159,15 @@ class _ZippedCircuit:
     """
 
     wide_circuit: cirq.Circuit
-    pairs: List[Tuple[cirq.Qid, cirq.Qid]]
-    combination: List[int]
+    pairs: list[tuple[cirq.Qid, cirq.Qid]]
+    combination: list[int]
     layer_i: int
     combination_i: int
 
 
 def _get_combinations_by_layer_for_isolated_xeb(
     circuits: Sequence[cirq.Circuit],
-) -> Tuple[List[CircuitLibraryCombination], List[cirq.Circuit]]:
+) -> tuple[list[CircuitLibraryCombination], list[cirq.Circuit]]:
     """Helper function used in `sample_2q_xeb_circuits`.
 
     This creates a CircuitLibraryCombination object for isolated XEB. First, the qubits
@@ -199,8 +188,8 @@ def _get_combinations_by_layer_for_isolated_xeb(
 
 
 def _zip_circuits(
-    circuits: Sequence[cirq.Circuit], combinations_by_layer: List[CircuitLibraryCombination]
-) -> List[_ZippedCircuit]:
+    circuits: Sequence[cirq.Circuit], combinations_by_layer: list[CircuitLibraryCombination]
+) -> list[_ZippedCircuit]:
     """Helper function used in `sample_2q_xeb_circuits` to zip together circuits.
 
     This takes a sequence of narrow `circuits` and "zips" them together according to the
@@ -214,7 +203,7 @@ def _zip_circuits(
         ):
             raise ValueError("`combinations_by_layer` has invalid indices.")
 
-    zipped_circuits: List[_ZippedCircuit] = []
+    zipped_circuits: list[_ZippedCircuit] = []
     for layer_i, layer_combinations in enumerate(combinations_by_layer):
         for combination_i, combination in enumerate(layer_combinations.combinations):
             wide_circuit = Circuit.zip(
@@ -236,10 +225,10 @@ def _zip_circuits(
 
 
 def _generate_sample_2q_xeb_tasks(
-    zipped_circuits: List[_ZippedCircuit], cycle_depths: Sequence[int]
-) -> List[_Sample2qXEBTask]:
+    zipped_circuits: list[_ZippedCircuit], cycle_depths: Sequence[int]
+) -> list[_Sample2qXEBTask]:
     """Helper function used in `sample_2q_xeb_circuits` to prepare circuits in sampling tasks."""
-    tasks: List[_Sample2qXEBTask] = []
+    tasks: list[_Sample2qXEBTask] = []
     for cycle_depth in cycle_depths:
         for zipped_circuit in zipped_circuits:
             circuit_depth = cycle_depth * 2 + 1
@@ -263,14 +252,14 @@ def _generate_sample_2q_xeb_tasks(
 
 
 def _execute_sample_2q_xeb_tasks_in_batches(
-    tasks: List[_Sample2qXEBTask],
+    tasks: list[_Sample2qXEBTask],
     sampler: cirq.Sampler,
-    combinations_by_layer: List[CircuitLibraryCombination],
+    combinations_by_layer: list[CircuitLibraryCombination],
     repetitions: int,
     batch_size: int,
     progress_bar: Callable[..., ContextManager],
-    dataset_directory: Optional[str] = None,
-) -> List[Dict[str, Any]]:
+    dataset_directory: str | None = None,
+) -> list[dict[str, Any]]:
     """Helper function used in `sample_2q_xeb_circuits` to batch and execute sampling tasks."""
     n_tasks = len(tasks)
     batched_tasks = [tasks[i : i + batch_size] for i in range(0, n_tasks, batch_size)]
@@ -298,10 +287,10 @@ def sample_2q_xeb_circuits(
     *,
     repetitions: int = 10_000,
     batch_size: int = 9,
-    progress_bar: Optional[Callable[..., ContextManager]] = tqdm.tqdm,
-    combinations_by_layer: Optional[List[CircuitLibraryCombination]] = None,
-    shuffle: Optional[cirq.RANDOM_STATE_OR_SEED_LIKE] = None,
-    dataset_directory: Optional[str] = None,
+    progress_bar: Callable[..., ContextManager] | None = tqdm.tqdm,
+    combinations_by_layer: list[CircuitLibraryCombination] | None = None,
+    shuffle: cirq.RANDOM_STATE_OR_SEED_LIKE | None = None,
+    dataset_directory: str | None = None,
 ):
     """Sample two-qubit XEB circuits given a sampler.
 

cirq/experiments/xeb_simulation.py

@@ -17,7 +17,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, Sequence, TYPE_CHECKING
+from typing import Any, Sequence, TYPE_CHECKING
 
 import numpy as np
 import pandas as pd
@@ -46,7 +46,7 @@ class _Simulate_2q_XEB_Circuit:
     def __init__(self, simulator: cirq.SimulatesIntermediateState):
         self.simulator = simulator
 
-    def __call__(self, task: _Simulate2qXEBTask) -> List[Dict[str, Any]]:
+    def __call__(self, task: _Simulate2qXEBTask) -> list[dict[str, Any]]:
         """Helper function for simulating a given (circuit, cycle_depth)."""
         circuit_i = task.circuit_i
         cycle_depths = set(task.cycle_depths)
@@ -57,7 +57,7 @@ class _Simulate_2q_XEB_Circuit:
         if max(cycle_depths) > circuit_max_cycle_depth:
             raise ValueError("`circuit` was not long enough to compute all `cycle_depths`.")
 
-        records: List[Dict[str, Any]] = []
+        records: list[dict[str, Any]] = []
         for moment_i, step_result in enumerate(
             self.simulator.simulate_moment_steps(circuit=circuit, param_resolver=param_resolver)
         ):
@@ -84,8 +84,8 @@ def simulate_2q_xeb_circuits(
     circuits: Sequence[cirq.Circuit],
     cycle_depths: Sequence[int],
     param_resolver: cirq.ParamResolverOrSimilarType = None,
-    pool: Optional[multiprocessing.pool.Pool] = None,
-    simulator: Optional[cirq.SimulatesIntermediateState] = None,
+    pool: multiprocessing.pool.Pool | None = None,
+    simulator: cirq.SimulatesIntermediateState | None = None,
 ):
     """Simulate two-qubit XEB circuits.
 

cirq/experiments/xeb_simulation_test.py

@@ -15,7 +15,7 @@
 from __future__ import annotations
 
 import multiprocessing
-from typing import Any, Dict, Iterator, Optional, Sequence
+from typing import Any, Iterator, Sequence
 
 import numpy as np
 import pandas as pd
@@ -74,7 +74,7 @@ def test_simulate_circuit_length_validation():
         _ = simulate_2q_xeb_circuits(circuits=circuits, cycle_depths=cycle_depths)
 
 
-def _ref_simulate_2q_xeb_circuit(task: Dict[str, Any]):
+def _ref_simulate_2q_xeb_circuit(task: dict[str, Any]):
     """Helper function for simulating a given (circuit, cycle_depth)."""
     circuit_i = task['circuit_i']
     cycle_depth = task['cycle_depth']
@@ -98,7 +98,7 @@ def _ref_simulate_2q_xeb_circuits(
     circuits: Sequence[cirq.Circuit],
     cycle_depths: Sequence[int],
     param_resolver: cirq.ParamResolverOrSimilarType = None,
-    pool: Optional[multiprocessing.pool.Pool] = None,
+    pool: multiprocessing.pool.Pool | None = None,
 ):
     """Reference implementation for `simulate_2q_xeb_circuits` that
     does each circuit independently instead of using intermediate states.

cirq/experiments/z_phase_calibration.py

@@ -18,7 +18,7 @@ from __future__ import annotations
 
 import multiprocessing
 import multiprocessing.pool
-from typing import Any, Dict, List, Optional, Sequence, Tuple, TYPE_CHECKING, Union
+from typing import Any, Sequence, TYPE_CHECKING
 
 import matplotlib.pyplot as plt
 import numpy as np
@@ -36,19 +36,19 @@ if TYPE_CHECKING:
 
 def z_phase_calibration_workflow(
     sampler: cirq.Sampler,
-    qubits: Optional[Sequence[cirq.GridQubit]] = None,
+    qubits: Sequence[cirq.GridQubit] | None = None,
     two_qubit_gate: cirq.Gate = ops.CZ,
-    options: Optional[xeb_fitting.XEBPhasedFSimCharacterizationOptions] = None,
+    options: xeb_fitting.XEBPhasedFSimCharacterizationOptions | None = None,
     n_repetitions: int = 10**4,
     n_combinations: int = 10,
     n_circuits: int = 20,
     cycle_depths: Sequence[int] = tuple(np.arange(3, 100, 20)),
     random_state: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
     atol: float = 1e-3,
-    num_workers_or_pool: Union[int, multiprocessing.pool.Pool] = -1,
-    pairs: Optional[Sequence[Tuple[cirq.GridQubit, cirq.GridQubit]]] = None,
+    num_workers_or_pool: int | multiprocessing.pool.Pool = -1,
+    pairs: Sequence[tuple[cirq.GridQubit, cirq.GridQubit]] | None = None,
     tags: Sequence[Any] = (),
-) -> Tuple[xeb_fitting.XEBCharacterizationResult, pd.DataFrame]:
+) -> tuple[xeb_fitting.XEBCharacterizationResult, pd.DataFrame]:
     """Perform z-phase calibration for excitation-preserving gates.
 
     For a given excitation-preserving two-qubit gate we assume an error model that can be described
@@ -91,7 +91,7 @@ def z_phase_calibration_workflow(
         - A `pd.DataFrame` comparing the before and after fidelities.
     """
 
-    pool: Optional[multiprocessing.pool.Pool] = None
+    pool: multiprocessing.pool.Pool | None = None
     local_pool = False
     if isinstance(num_workers_or_pool, multiprocessing.pool.Pool):
         pool = num_workers_or_pool  # pragma: no cover
@@ -149,19 +149,19 @@ def z_phase_calibration_workflow(
 
 def calibrate_z_phases(
     sampler: cirq.Sampler,
-    qubits: Optional[Sequence[cirq.GridQubit]] = None,
+    qubits: Sequence[cirq.GridQubit] | None = None,
     two_qubit_gate: cirq.Gate = ops.CZ,
-    options: Optional[xeb_fitting.XEBPhasedFSimCharacterizationOptions] = None,
+    options: xeb_fitting.XEBPhasedFSimCharacterizationOptions | None = None,
     n_repetitions: int = 10**4,
     n_combinations: int = 10,
     n_circuits: int = 20,
     cycle_depths: Sequence[int] = tuple(np.arange(3, 100, 20)),
     random_state: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
     atol: float = 1e-3,
-    num_workers_or_pool: Union[int, multiprocessing.pool.Pool] = -1,
-    pairs: Optional[Sequence[Tuple[cirq.GridQubit, cirq.GridQubit]]] = None,
+    num_workers_or_pool: int | multiprocessing.pool.Pool = -1,
+    pairs: Sequence[tuple[cirq.GridQubit, cirq.GridQubit]] | None = None,
     tags: Sequence[Any] = (),
-) -> Dict[Tuple[cirq.Qid, cirq.Qid], cirq.PhasedFSimGate]:
+) -> dict[tuple[cirq.Qid, cirq.Qid], cirq.PhasedFSimGate]:
     """Perform z-phase calibration for excitation-preserving gates.
 
     For a given excitation-preserving two-qubit gate we assume an error model that can be described
@@ -242,11 +242,11 @@ def calibrate_z_phases(
 
 def plot_z_phase_calibration_result(
     before_after_df: pd.DataFrame,
-    axes: Optional[np.ndarray[Tuple[int, int], np.dtype[np.object_]]] = None,
-    pairs: Optional[Sequence[Tuple[cirq.Qid, cirq.Qid]]] = None,
+    axes: np.ndarray[tuple[int, int], np.dtype[np.object_]] | None = None,
+    pairs: Sequence[tuple[cirq.Qid, cirq.Qid]] | None = None,
     *,
     with_error_bars: bool = False,
-) -> np.ndarray[Tuple[int, int], np.dtype[np.object_]]:
+) -> np.ndarray[tuple[int, int], np.dtype[np.object_]]:
     """A helper method to plot the result of running z-phase calibration.
 
     Note that the plotted fidelity is a statistical estimate of the true fidelity and as a result
@@ -290,7 +290,7 @@ def plot_z_phase_calibration_result(
     return axes
 
 
-def _z_angles(old: ops.PhasedFSimGate, new: ops.PhasedFSimGate) -> Tuple[float, float, float]:
+def _z_angles(old: ops.PhasedFSimGate, new: ops.PhasedFSimGate) -> tuple[float, float, float]:
     """Computes a set of possible 3 z-phases that result in the change in gamma, zeta, and chi."""
     # This procedure is the inverse of PhasedFSimGate.from_fsim_rz
     delta_gamma = new.gamma - old.gamma
@@ -305,7 +305,7 @@ class CalibrationTransformer:
     def __init__(
         self,
         target: cirq.Gate,
-        calibration_map: Dict[Tuple[cirq.Qid, cirq.Qid], cirq.PhasedFSimGate],
+        calibration_map: dict[tuple[cirq.Qid, cirq.Qid], cirq.PhasedFSimGate],
     ):
         """Create a CalibrationTransformer.
 
@@ -332,7 +332,7 @@ class CalibrationTransformer:
         self,
         circuit: cirq.AbstractCircuit,
         *,
-        context: Optional[transformer_api.TransformerContext] = None,
+        context: transformer_api.TransformerContext | None = None,
     ) -> cirq.Circuit:
         """Adds 3 ZPowGates around each calibrated gate to cancel the effect of Z phases.
 
@@ -343,7 +343,7 @@ class CalibrationTransformer:
         Returns:
             New circuit with the extra ZPowGates.
         """
-        new_moments: List[Union[List[cirq.Operation], cirq.Moment]] = []
+        new_moments: list[list[cirq.Operation] | cirq.Moment] = []
         for moment in circuit:
             before = []
             after = []

cirq/interop/quirk/cells/arithmetic_cells.py

@@ -15,20 +15,7 @@
 from __future__ import annotations
 
 import inspect
-from typing import (
-    Any,
-    Callable,
-    cast,
-    Dict,
-    Iterable,
-    Iterator,
-    List,
-    Optional,
-    Sequence,
-    Tuple,
-    TYPE_CHECKING,
-    Union,
-)
+from typing import Any, Callable, cast, Iterable, Iterator, Sequence, TYPE_CHECKING
 
 from cirq import ops, value
 from cirq.interop.quirk.cells.cell import Cell, CELL_SIZES, CellMaker
@@ -52,7 +39,7 @@ class QuirkArithmeticGate(ops.ArithmeticGate):
     """
 
     def __init__(
-        self, identifier: str, target: Sequence[int], inputs: Sequence[Union[Sequence[int], int]]
+        self, identifier: str, target: Sequence[int], inputs: Sequence[Sequence[int] | int]
     ):
         """Inits QuirkArithmeticGate.
 
@@ -68,8 +55,8 @@ class QuirkArithmeticGate(ops.ArithmeticGate):
                 too small modulus.
         """
         self.identifier = identifier
-        self.target: Tuple[int, ...] = tuple(target)
-        self.inputs: Tuple[Union[Sequence[int], int], ...] = tuple(
+        self.target: tuple[int, ...] = tuple(target)
+        self.inputs: tuple[Sequence[int] | int, ...] = tuple(
             e if isinstance(e, int) else tuple(e) for e in inputs
         )
 
@@ -89,10 +76,10 @@ class QuirkArithmeticGate(ops.ArithmeticGate):
     def _value_equality_values_(self) -> Any:
         return self.identifier, self.target, self.inputs
 
-    def registers(self) -> Sequence[Union[int, Sequence[int]]]:
+    def registers(self) -> Sequence[int | Sequence[int]]:
         return [self.target, *self.inputs]
 
-    def with_registers(self, *new_registers: Union[int, Sequence[int]]) -> QuirkArithmeticGate:
+    def with_registers(self, *new_registers: int | Sequence[int]) -> QuirkArithmeticGate:
         if len(new_registers) != len(self.inputs) + 1:
             raise ValueError(
                 'Wrong number of registers.\n'
@@ -109,13 +96,13 @@ class QuirkArithmeticGate(ops.ArithmeticGate):
 
         return QuirkArithmeticGate(self.identifier, new_registers[0], new_registers[1:])
 
-    def apply(self, *registers: int) -> Union[int, Iterable[int]]:
+    def apply(self, *registers: int) -> int | Iterable[int]:
         return self.operation(*registers)
 
-    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> List[str]:
+    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> list[str]:
         lettered_args = list(zip(self.operation.letters, self.inputs))
 
-        result: List[str] = []
+        result: list[str] = []
 
         # Target register labels.
         consts = ''.join(
@@ -141,12 +128,12 @@ class QuirkArithmeticGate(ops.ArithmeticGate):
         )
 
 
-_IntsToIntCallable = Union[
-    Callable[[int], int],
-    Callable[[int, int], int],
-    Callable[[int, int, int], int],
-    Callable[[int, int, int, int], int],
-]
+_IntsToIntCallable = (
+    Callable[[int], int]
+    | Callable[[int, int], int]
+    | Callable[[int, int, int], int]
+    | Callable[[int, int, int, int], int]
+)
 
 
 class _QuirkArithmeticCallable:
@@ -161,7 +148,7 @@ class _QuirkArithmeticCallable:
         self.func = func
 
         # The lambda parameter names indicate the input letter to match.
-        letters: List[str] = list(inspect.signature(self.func).parameters)
+        letters: list[str] = list(inspect.signature(self.func).parameters)
         # The target is always first, and should be ignored.
         assert letters and letters[0] == 'x'
         self.letters = tuple(letters[1:])
@@ -187,7 +174,7 @@ class ArithmeticCell(Cell):
         self,
         identifier: str,
         target: Sequence[cirq.Qid],
-        inputs: Sequence[Union[None, Sequence[cirq.Qid], int]],
+        inputs: Sequence[None | Sequence[cirq.Qid] | int],
     ):
         self.identifier = identifier
         self.target = tuple(target)
@@ -207,7 +194,7 @@ class ArithmeticCell(Cell):
             f'\n    {self.inputs!r})'
         )
 
-    def with_line_qubits_mapped_to(self, qubits: List[cirq.Qid]) -> Cell:
+    def with_line_qubits_mapped_to(self, qubits: list[cirq.Qid]) -> Cell:
         return ArithmeticCell(
             identifier=self.identifier,
             target=Cell._replace_qubits(self.target, qubits),
@@ -221,7 +208,7 @@ class ArithmeticCell(Cell):
     def operation(self):
         return ARITHMETIC_OP_TABLE[self.identifier]
 
-    def with_input(self, letter: str, register: Union[Sequence[cirq.Qid], int]) -> ArithmeticCell:
+    def with_input(self, letter: str, register: Sequence[cirq.Qid] | int) -> ArithmeticCell:
         new_inputs = [
             reg if letter != reg_letter else register
             for reg, reg_letter in zip(self.inputs, self.operation.letters)
@@ -235,7 +222,7 @@ class ArithmeticCell(Cell):
         if missing_inputs:
             raise ValueError(f'Missing input: {sorted(missing_inputs)}')
 
-        inputs = cast(Sequence[Union[Sequence['cirq.Qid'], int]], self.inputs)
+        inputs = cast(Sequence[Sequence['cirq.Qid'] | int], self.inputs)
         qubits = self.target + tuple(q for i in self.inputs if isinstance(i, Sequence) for q in i)
         return QuirkArithmeticGate(
             self.identifier,
@@ -304,7 +291,7 @@ def _generate_helper() -> Iterator[CellMaker]:
     )
 
 
-def _extended_gcd(a: int, b: int) -> Tuple[int, int, int]:
+def _extended_gcd(a: int, b: int) -> tuple[int, int, int]:
     if a == 0:
         return b, 0, 1
     gcd, y, x = _extended_gcd(b % a, a)
@@ -360,9 +347,9 @@ def _arithmetic_gate(identifier: str, size: int, func: _IntsToIntCallable) -> Ce
     )
 
 
-ARITHMETIC_OP_TABLE: Dict[str, _QuirkArithmeticCallable] = {}
+ARITHMETIC_OP_TABLE: dict[str, _QuirkArithmeticCallable] = {}
 # Caching is necessary in order to avoid overwriting entries in the table.
-_cached_cells: Optional[Tuple[CellMaker, ...]] = None
+_cached_cells: tuple[CellMaker, ...] | None = None
 
 
 def generate_all_arithmetic_cell_makers() -> Iterable[CellMaker]: