cirq-core 1.5.0.dev20250409222543__py3-none-any.whl → 1.6.0__py3-none-any.whl

cirq/experiments/xeb_fitting.py

@@ -11,10 +11,14 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+
 """Estimation of fidelity associated with experimental circuit executions."""
+
+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
@@ -41,10 +45,10 @@ 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,
-    param_resolver: 'cirq.ParamResolverOrSimilarType' = None,
-    pool: Optional['multiprocessing.pool.Pool'] = None,
+    circuits: Sequence[cirq.Circuit],
+    cycle_depths: Sequence[int] | None = None,
+    param_resolver: cirq.ParamResolverOrSimilarType = None,
+    pool: multiprocessing.pool.Pool | None = None,
 ) -> pd.DataFrame:
     """Simulate and benchmark two-qubit XEB circuits.
 
@@ -144,21 +148,21 @@ def benchmark_2q_xeb_fidelities(
 class XEBCharacterizationOptions(ABC):
     @staticmethod
     @abstractmethod
-    def should_parameterize(op: 'cirq.Operation') -> bool:
+    def should_parameterize(op: cirq.Operation) -> bool:
         """Whether to replace `op` with a parameterized version."""
 
     @abstractmethod
-    def get_parameterized_gate(self) -> 'cirq.Gate':
+    def get_parameterized_gate(self) -> cirq.Gate:
         """The parameterized gate to use."""
 
     @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:
@@ -221,10 +225,10 @@ def _try_defaults_from_unitary(gate: 'cirq.Gate') -> Optional[Dict[str, 'cirq.TP
     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,
@@ -284,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),
@@ -299,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()
@@ -308,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
@@ -347,7 +351,7 @@ class XEBPhasedFSimCharacterizationOptions(XEBCharacterizationOptions):
         return ops.PhasedFSimGate(theta=theta, zeta=zeta, chi=chi, gamma=gamma, phi=phi)
 
     @staticmethod
-    def should_parameterize(op: 'cirq.Operation') -> bool:
+    def should_parameterize(op: cirq.Operation) -> bool:
         return isinstance(op.gate, (ops.PhasedFSimGate, ops.ISwapPowGate, ops.FSimGate))
 
     def defaults_set(self) -> bool:
@@ -369,7 +373,7 @@ class XEBPhasedFSimCharacterizationOptions(XEBCharacterizationOptions):
         return False
 
     def with_defaults_from_gate(
-        self, gate: 'cirq.Gate', gate_to_angles_func=phased_fsim_angles_from_gate
+        self, gate: cirq.Gate, gate_to_angles_func=phased_fsim_angles_from_gate
     ):
         """A new Options class with {angle}_defaults inferred from `gate`.
 
@@ -397,10 +401,10 @@ def SqrtISwapXEBOptions(*args, **kwargs):
 
 
 def parameterize_circuit(
-    circuit: 'cirq.Circuit',
+    circuit: cirq.Circuit,
     options: XEBCharacterizationOptions,
-    target_gatefamily: Optional[ops.GateFamily] = None,
-) -> 'cirq.Circuit':
+    target_gatefamily: ops.GateFamily | None = None,
+) -> cirq.Circuit:
     """Parameterize PhasedFSim-like gates in a given circuit according to
     `phased_fsim_options`.
     """
@@ -417,7 +421,7 @@ def parameterize_circuit(
     )
 
 
-QPair_T = Tuple['cirq.Qid', 'cirq.Qid']
+QPair_T = tuple['cirq.Qid', 'cirq.Qid']
 
 
 @dataclasses.dataclass(frozen=True)
@@ -432,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.
@@ -496,13 +500,13 @@ def characterize_phased_fsim_parameters_with_xeb(
         method='nelder-mead',
     )
 
-    final_params: 'cirq.ParamDictType' = dict(zip(names, optimization_result.x))
+    final_params: cirq.ParamDictType = dict(zip(names, optimization_result.x))
     fidelities_df = benchmark_2q_xeb_fidelities(
         sampled_df, parameterized_circuits, cycle_depths, param_resolver=final_params
     )
     return XEBCharacterizationResult(
         optimization_results={pair: optimization_result},
-        final_params={pair: final_params},  # type: ignore[dict-item]
+        final_params={pair: final_params},
         fidelities_df=fidelities_df,
     )
 
@@ -512,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
@@ -535,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.
@@ -614,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

@@ -11,23 +11,16 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+
 """Estimation of fidelity associated with experimental circuit executions."""
+
+from __future__ import annotations
+
 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
@@ -52,16 +45,16 @@ class _Sample2qXEBTask:
     cycle_depth: int
     layer_i: int
     combination_i: int
-    prepared_circuit: 'cirq.AbstractCircuit'
-    combination: List[int]
+    prepared_circuit: cirq.AbstractCircuit
+    combination: list[int]
 
 
 class _SampleInBatches:
     def __init__(
         self,
-        sampler: 'cirq.Sampler',
+        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.
@@ -76,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()
@@ -107,9 +100,9 @@ class _SampleInBatches:
         return records
 
 
-def _verify_and_get_two_qubits_from_circuits(circuits: Sequence['cirq.Circuit']):
+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:
@@ -119,7 +112,7 @@ def _verify_and_get_two_qubits_from_circuits(circuits: Sequence['cirq.Circuit'])
     return all_qubits_list
 
 
-def _verify_two_line_qubits_from_circuits(circuits: Sequence['cirq.Circuit']):
+def _verify_two_line_qubits_from_circuits(circuits: Sequence[cirq.Circuit]):
     if _verify_and_get_two_qubits_from_circuits(circuits) != devices.LineQubit.range(2):
         raise ValueError(
             "`circuits` should be a sequence of circuits each operating "
@@ -165,16 +158,16 @@ class _ZippedCircuit:
             any behavior. It is propagated to the output result object.
     """
 
-    wide_circuit: 'cirq.Circuit'
-    pairs: List[Tuple['cirq.Qid', 'cirq.Qid']]
-    combination: List[int]
+    wide_circuit: cirq.Circuit
+    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']]:
+    circuits: Sequence[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
@@ -195,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
@@ -210,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(
@@ -232,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
@@ -259,14 +252,14 @@ def _generate_sample_2q_xeb_tasks(
 
 
 def _execute_sample_2q_xeb_tasks_in_batches(
-    tasks: List[_Sample2qXEBTask],
-    sampler: 'cirq.Sampler',
-    combinations_by_layer: List[CircuitLibraryCombination],
+    tasks: list[_Sample2qXEBTask],
+    sampler: cirq.Sampler,
+    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)]
@@ -288,16 +281,16 @@ def _execute_sample_2q_xeb_tasks_in_batches(
 
 
 def sample_2q_xeb_circuits(
-    sampler: 'cirq.Sampler',
-    circuits: Sequence['cirq.Circuit'],
+    sampler: cirq.Sampler,
+    circuits: Sequence[cirq.Circuit],
     cycle_depths: Sequence[int],
     *,
     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.
 
@@ -348,8 +341,8 @@ def sample_2q_xeb_circuits(
     # Construct truncated-with-measurement circuits to run.
     tasks = _generate_sample_2q_xeb_tasks(zipped_circuits, cycle_depths)
     if shuffle is not None:
-        shuffle = value.parse_random_state(shuffle)
-        shuffle.shuffle(tasks)
+        prng = value.parse_random_state(shuffle)
+        prng.shuffle(tasks)  # type: ignore[arg-type]
 
     # Batch and run tasks.
     records = _execute_sample_2q_xeb_tasks_in_batches(

cirq/experiments/xeb_sampling_test.py

@@ -11,6 +11,9 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+
+from __future__ import annotations
+
 import glob
 import itertools
 from typing import Iterable

cirq/experiments/xeb_simulation.py

@@ -11,9 +11,13 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+
 """Estimation of fidelity associated with experimental circuit executions."""
+
+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
@@ -32,17 +36,17 @@ class _Simulate2qXEBTask:
 
     circuit_i: int
     cycle_depths: Sequence[int]
-    circuit: 'cirq.Circuit'
-    param_resolver: 'cirq.ParamResolverOrSimilarType'
+    circuit: cirq.Circuit
+    param_resolver: cirq.ParamResolverOrSimilarType
 
 
 class _Simulate_2q_XEB_Circuit:
     """Closure used in `simulate_2q_xeb_circuits` so it works with multiprocessing."""
 
-    def __init__(self, simulator: 'cirq.SimulatesIntermediateState'):
+    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)
@@ -53,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)
         ):
@@ -77,11 +81,11 @@ class _Simulate_2q_XEB_Circuit:
 
 
 def simulate_2q_xeb_circuits(
-    circuits: Sequence['cirq.Circuit'],
+    circuits: Sequence[cirq.Circuit],
     cycle_depths: Sequence[int],
-    param_resolver: 'cirq.ParamResolverOrSimilarType' = None,
-    pool: Optional['multiprocessing.pool.Pool'] = None,
-    simulator: Optional['cirq.SimulatesIntermediateState'] = None,
+    param_resolver: cirq.ParamResolverOrSimilarType = 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']
@@ -95,10 +95,10 @@ def _ref_simulate_2q_xeb_circuit(task: Dict[str, Any]):
 
 
 def _ref_simulate_2q_xeb_circuits(
-    circuits: Sequence['cirq.Circuit'],
+    circuits: Sequence[cirq.Circuit],
     cycle_depths: Sequence[int],
-    param_resolver: 'cirq.ParamResolverOrSimilarType' = None,
-    pool: Optional['multiprocessing.pool.Pool'] = None,
+    param_resolver: cirq.ParamResolverOrSimilarType = 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

@@ -13,9 +13,12 @@
 # limitations under the License.
 
 """Provides a method to do z-phase calibration for excitation-preserving gates."""
+
+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
@@ -32,20 +35,20 @@ if TYPE_CHECKING:
 
 
 def z_phase_calibration_workflow(
-    sampler: 'cirq.Sampler',
-    qubits: Optional[Sequence['cirq.GridQubit']] = None,
-    two_qubit_gate: 'cirq.Gate' = ops.CZ,
-    options: Optional[xeb_fitting.XEBPhasedFSimCharacterizationOptions] = None,
+    sampler: cirq.Sampler,
+    qubits: Sequence[cirq.GridQubit] | None = None,
+    two_qubit_gate: cirq.Gate = ops.CZ,
+    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,
+    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
@@ -88,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
@@ -145,20 +148,20 @@ def z_phase_calibration_workflow(
 
 
 def calibrate_z_phases(
-    sampler: 'cirq.Sampler',
-    qubits: Optional[Sequence['cirq.GridQubit']] = None,
-    two_qubit_gate: 'cirq.Gate' = ops.CZ,
-    options: Optional[xeb_fitting.XEBPhasedFSimCharacterizationOptions] = None,
+    sampler: cirq.Sampler,
+    qubits: Sequence[cirq.GridQubit] | None = None,
+    two_qubit_gate: cirq.Gate = ops.CZ,
+    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,
+    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
@@ -238,12 +241,12 @@ def calibrate_z_phases(
 
 
 def plot_z_phase_calibration_result(
-    before_after_df: 'pd.DataFrame',
-    axes: Optional[np.ndarray[Sequence[Sequence['plt.Axes']], np.dtype[np.object_]]] = None,
-    pairs: Optional[Sequence[Tuple['cirq.Qid', 'cirq.Qid']]] = None,
+    before_after_df: pd.DataFrame,
+    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[Sequence[Sequence['plt.Axes']], 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
@@ -287,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
@@ -301,8 +304,8 @@ class CalibrationTransformer:
 
     def __init__(
         self,
-        target: 'cirq.Gate',
-        calibration_map: Dict[Tuple['cirq.Qid', 'cirq.Qid'], 'cirq.PhasedFSimGate'],
+        target: cirq.Gate,
+        calibration_map: dict[tuple[cirq.Qid, cirq.Qid], cirq.PhasedFSimGate],
     ):
         """Create a CalibrationTransformer.
 
@@ -327,10 +330,10 @@ class CalibrationTransformer:
 
     def __call__(
         self,
-        circuit: 'cirq.AbstractCircuit',
+        circuit: cirq.AbstractCircuit,
         *,
-        context: Optional[transformer_api.TransformerContext] = None,
-    ) -> 'cirq.Circuit':
+        context: transformer_api.TransformerContext | None = None,
+    ) -> cirq.Circuit:
         """Adds 3 ZPowGates around each calibrated gate to cancel the effect of Z phases.
 
         Args:
@@ -340,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 = []