cirq-core 1.6.0.dev20250416221104__py3-none-any.whl → 1.6.0.dev20250417204649__py3-none-any.whl

cirq/experiments/two_qubit_xeb.py

@@ -13,6 +13,9 @@
 # limitations under the License.
 
 """Provides functions for running and analyzing two-qubit XEB experiments."""
+
+from __future__ import annotations
+
 import functools
 import itertools
 from dataclasses import dataclass
@@ -45,22 +48,22 @@ 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) -> Optional[Sequence[cirq.GridQubit]]:
     if hasattr(sampler, 'processor'):
         device = sampler.processor.get_device()
         return sorted(device.metadata.qubit_set)
     return None
 
 
-def _manhattan_distance(qubit1: 'cirq.GridQubit', qubit2: 'cirq.GridQubit') -> int:
+def _manhattan_distance(qubit1: cirq.GridQubit, qubit2: cirq.GridQubit) -> int:
     return abs(qubit1.row - qubit2.row) + abs(qubit1.col - qubit2.col)
 
 
 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']]]:
+    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]]]:
     """Extract qubits and pairs from sampler.
 
 
@@ -103,14 +106,14 @@ 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]:
         return {
             (min(q0, q1), max(q0, q1)): i
             for i, (_, _, (q0, q1)) in enumerate(self.fidelities.index)
         }
 
     @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:
@@ -127,7 +130,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
         }
 
@@ -139,11 +142,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: Optional[plt.Axes] = None, **plot_kwargs
     ) -> plt.Axes:
         """plot the fitted model to for xeb error of a qubit pair.
 
@@ -185,17 +184,17 @@ class TwoQubitXEBResult:
             q0, q1 = q1, q0
         return self.fidelities.iloc[self._qubit_pair_map[(q0, q1)]]
 
-    def xeb_fidelity(self, q0: 'cirq.GridQubit', q1: 'cirq.GridQubit') -> float:
+    def xeb_fidelity(self, q0: cirq.GridQubit, q1: cirq.GridQubit) -> float:
         """Return the XEB fidelity of a qubit pair."""
         return noise_utils.decay_constant_to_xeb_fidelity(
             self._record(q0, q1).layer_fid, num_qubits=2
         )
 
-    def xeb_error(self, q0: 'cirq.GridQubit', q1: 'cirq.GridQubit') -> float:
+    def xeb_error(self, q0: cirq.GridQubit, q1: cirq.GridQubit) -> float:
         """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}
 
@@ -219,7 +218,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(
@@ -242,33 +241,33 @@ 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
-    def single_qubit_pauli_error(self) -> Mapping['cirq.Qid', float]:
+    def single_qubit_pauli_error(self) -> Mapping[cirq.Qid, float]:
         """Return the single-qubit Pauli error for all qubits (RB results)."""
         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()
 
-        def _pauli_error(q0: 'cirq.GridQubit', q1: 'cirq.GridQubit') -> float:
+        def _pauli_error(q0: cirq.GridQubit, q1: cirq.GridQubit) -> float:
             q0, q1 = sorted([q0, q1])
             return xeb[(q0, q1)] - single_q_paulis[q0] - single_q_paulis[q1]
 
         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(
             {
@@ -278,7 +277,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(
             {
@@ -289,7 +288,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'.
@@ -393,21 +392,21 @@ class InferredXEBResult:
 
 
 def parallel_xeb_workflow(
-    sampler: 'cirq.Sampler',
-    qubits: Optional[Sequence['cirq.GridQubit']] = None,
-    entangling_gate: 'cirq.Gate' = ops.CZ,
+    sampler: cirq.Sampler,
+    qubits: Optional[Sequence[cirq.GridQubit]] = 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,
+    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,
+    pairs: Optional[Sequence[tuple[cirq.GridQubit, cirq.GridQubit]]] = None,
+    pool: Optional[multiprocessing.pool.Pool] = 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:
@@ -483,16 +482,16 @@ def parallel_xeb_workflow(
 
 
 def parallel_two_qubit_xeb(
-    sampler: 'cirq.Sampler',
-    qubits: Optional[Sequence['cirq.GridQubit']] = None,
-    entangling_gate: 'cirq.Gate' = ops.CZ,
+    sampler: cirq.Sampler,
+    qubits: Optional[Sequence[cirq.GridQubit]] = 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,
+    random_state: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
     ax: Optional[plt.Axes] = None,
-    pairs: Optional[Sequence[tuple['cirq.GridQubit', 'cirq.GridQubit']]] = None,
+    pairs: Optional[Sequence[tuple[cirq.GridQubit, cirq.GridQubit]]] = None,
     batch_size: int = 9,
     tags: Sequence[Any] = (),
     **plot_kwargs,
@@ -540,18 +539,18 @@ def parallel_two_qubit_xeb(
 
 
 def run_rb_and_xeb(
-    sampler: 'cirq.Sampler',
-    qubits: Optional[Sequence['cirq.GridQubit']] = None,
+    sampler: cirq.Sampler,
+    qubits: Optional[Sequence[cirq.GridQubit]] = None,
     repetitions: int = 10**3,
     num_circuits: int = 20,
     num_clifford_range: Sequence[int] = tuple(
         np.logspace(np.log10(5), np.log10(1000), 5, dtype=int)
     ),
-    entangling_gate: 'cirq.Gate' = ops.CZ,
+    entangling_gate: cirq.Gate = ops.CZ,
     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,
+    random_state: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
+    pairs: Optional[Sequence[tuple[cirq.GridQubit, cirq.GridQubit]]] = None,
     batch_size: int = 9,
     tags: Sequence[Any] = (),
 ) -> InferredXEBResult:

cirq/experiments/two_qubit_xeb_test.py

@@ -26,7 +26,7 @@ import cirq
 from cirq.experiments.qubit_characterizations import ParallelRandomizedBenchmarkingResult
 
 
-def _manhattan_distance(qubit1: 'cirq.GridQubit', qubit2: 'cirq.GridQubit') -> int:
+def _manhattan_distance(qubit1: cirq.GridQubit, qubit2: cirq.GridQubit) -> int:
     return abs(qubit1.row - qubit2.row) + abs(qubit1.col - qubit2.col)
 
 

cirq/experiments/xeb_fitting.py

@@ -11,7 +11,11 @@
 # 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
@@ -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'],
+    circuits: Sequence[cirq.Circuit],
     cycle_depths: Optional[Sequence[int]] = None,
-    param_resolver: 'cirq.ParamResolverOrSimilarType' = None,
-    pool: Optional['multiprocessing.pool.Pool'] = None,
+    param_resolver: cirq.ParamResolverOrSimilarType = None,
+    pool: Optional[multiprocessing.pool.Pool] = None,
 ) -> pd.DataFrame:
     """Simulate and benchmark two-qubit XEB circuits.
 
@@ -144,11 +148,11 @@ 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
@@ -158,7 +162,7 @@ class XEBCharacterizationOptions(ABC):
         """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) -> Optional[Dict[str, cirq.TParamVal]]:
     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,
@@ -290,7 +294,7 @@ class XEBPhasedFSimCharacterizationOptions(XEBCharacterizationOptions):
     gamma_default: Optional[float] = None
     phi_default: Optional[float] = None
 
-    def _iter_angles(self) -> Iterable[Tuple[bool, Optional[float], 'sympy.Symbol']]:
+    def _iter_angles(self) -> Iterable[Tuple[bool, Optional[float], 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[Optional[float], sympy.Symbol]]:
         yield from (
             (default, symbol)
             for characterize, default, symbol in self._iter_angles()
@@ -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':
+) -> cirq.Circuit:
     """Parameterize PhasedFSim-like gates in a given circuit according to
     `phased_fsim_options`.
     """
@@ -432,21 +436,21 @@ class XEBCharacterizationResult:
             fitting the characterization.
     """
 
-    optimization_results: Dict[QPair_T, 'scipy.optimize.OptimizeResult']
+    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: Optional[multiprocessing.pool.Pool] = None,
 ) -> XEBCharacterizationResult:
     """Run a classical optimization to fit phased fsim parameters to experimental data, and
     thereby characterize PhasedFSim-like gates.
@@ -496,7 +500,7 @@ 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
     )
@@ -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: Optional[multiprocessing.pool.Pool] = None,
 ) -> XEBCharacterizationResult:
     """Run a classical optimization to fit phased fsim parameters to experimental data, and
     thereby characterize PhasedFSim-like gates grouped by pairs.

cirq/experiments/xeb_sampling.py

@@ -11,7 +11,11 @@
 # 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
@@ -52,14 +56,14 @@ class _Sample2qXEBTask:
     cycle_depth: int
     layer_i: int
     combination_i: int
-    prepared_circuit: 'cirq.AbstractCircuit'
+    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],
     ):
@@ -107,9 +111,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 +123,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 +169,16 @@ class _ZippedCircuit:
             any behavior. It is propagated to the output result object.
     """
 
-    wide_circuit: 'cirq.Circuit'
-    pairs: List[Tuple['cirq.Qid', 'cirq.Qid']]
+    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,7 +199,7 @@ def _get_combinations_by_layer_for_isolated_xeb(
 
 
 def _zip_circuits(
-    circuits: Sequence['cirq.Circuit'], combinations_by_layer: List[CircuitLibraryCombination]
+    circuits: Sequence[cirq.Circuit], combinations_by_layer: List[CircuitLibraryCombination]
 ) -> List[_ZippedCircuit]:
     """Helper function used in `sample_2q_xeb_circuits` to zip together circuits.
 
@@ -260,7 +264,7 @@ def _generate_sample_2q_xeb_tasks(
 
 def _execute_sample_2q_xeb_tasks_in_batches(
     tasks: List[_Sample2qXEBTask],
-    sampler: 'cirq.Sampler',
+    sampler: cirq.Sampler,
     combinations_by_layer: List[CircuitLibraryCombination],
     repetitions: int,
     batch_size: int,
@@ -288,15 +292,15 @@ 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,
+    shuffle: Optional[cirq.RANDOM_STATE_OR_SEED_LIKE] = None,
     dataset_directory: Optional[str] = None,
 ):
     """Sample two-qubit XEB circuits given a sampler.

cirq/experiments/xeb_simulation.py

@@ -11,7 +11,11 @@
 # 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
 
@@ -32,14 +36,14 @@ 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]]:
@@ -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: Optional[multiprocessing.pool.Pool] = None,
+    simulator: Optional[cirq.SimulatesIntermediateState] = None,
 ):
     """Simulate two-qubit XEB circuits.
 

cirq/experiments/xeb_simulation_test.py

@@ -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: Optional[multiprocessing.pool.Pool] = None,
 ):
     """Reference implementation for `simulate_2q_xeb_circuits` that
     does each circuit independently instead of using intermediate states.