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

cirq/experiments/t1_decay_experiment.py

@@ -12,8 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import warnings
-from typing import Any, cast, Optional, Sequence, TYPE_CHECKING
+from typing import Any, cast, Sequence, TYPE_CHECKING
 
 import numpy as np
 import pandas as pd
@@ -31,14 +33,14 @@ optimize = _import.LazyLoader("optimize", globals(), "scipy.optimize")
 
 
 def t1_decay(
-    sampler: 'cirq.Sampler',
+    sampler: cirq.Sampler,
     *,
-    qubit: 'cirq.Qid',
+    qubit: cirq.Qid,
     num_points: int,
-    max_delay: 'cirq.DURATION_LIKE',
-    min_delay: 'cirq.DURATION_LIKE' = None,
+    max_delay: cirq.DURATION_LIKE,
+    min_delay: cirq.DURATION_LIKE = None,
     repetitions: int = 1000,
-) -> 'cirq.experiments.T1DecayResult':
+) -> cirq.experiments.T1DecayResult:
     """Runs a t1 decay experiment.
 
     Initializes a qubit into the |1⟩ state, waits for a variable amount of time,
@@ -144,7 +146,7 @@ class T1DecayResult:
             return np.nan
 
     def plot(
-        self, ax: Optional[plt.Axes] = None, include_fit: bool = False, **plot_kwargs: Any
+        self, ax: plt.Axes | None = None, include_fit: bool = False, **plot_kwargs: Any
     ) -> plt.Axes:
         """Plots the excited state probability vs the amount of delay.
 

cirq/experiments/t1_decay_experiment_test.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import numpy as np
 import pandas as pd
 import pytest
@@ -20,7 +22,7 @@ import sympy
 import cirq
 
 
-def test_init_result():
+def test_init_result() -> None:
     data = pd.DataFrame(
         columns=['delay_ns', 'false_count', 'true_count'],
         index=range(2),
@@ -31,7 +33,7 @@ def test_init_result():
 
 
 @pytest.mark.usefixtures('closefigures')
-def test_plot_does_not_raise_error():
+def test_plot_does_not_raise_error() -> None:
     class _TimeDependentDecay(cirq.NoiseModel):
         def noisy_moment(self, moment, system_qubits):
             duration = max(
@@ -55,7 +57,7 @@ def test_plot_does_not_raise_error():
     results.plot(include_fit=True)
 
 
-def test_result_eq():
+def test_result_eq() -> None:
     eq = cirq.testing.EqualsTester()
     eq.make_equality_group(
         lambda: cirq.experiments.T1DecayResult(
@@ -75,7 +77,7 @@ def test_result_eq():
     )
 
 
-def test_sudden_decay_results():
+def test_sudden_decay_results() -> None:
     class _SuddenDecay(cirq.NoiseModel):
         def noisy_moment(self, moment, system_qubits):
             duration = max(
@@ -107,7 +109,7 @@ def test_sudden_decay_results():
     )
 
 
-def test_all_on_results():
+def test_all_on_results() -> None:
     results = cirq.experiments.t1_decay(
         sampler=cirq.Simulator(),
         qubit=cirq.GridQubit(0, 0),
@@ -126,7 +128,7 @@ def test_all_on_results():
     assert results == desired, f'{results.data=} {desired.data=}'
 
 
-def test_all_off_results():
+def test_all_off_results() -> None:
     results = cirq.experiments.t1_decay(
         sampler=cirq.DensityMatrixSimulator(noise=cirq.amplitude_damp(1)),
         qubit=cirq.GridQubit(0, 0),
@@ -146,7 +148,7 @@ def test_all_off_results():
 
 
 @pytest.mark.usefixtures('closefigures')
-def test_curve_fit_plot_works():
+def test_curve_fit_plot_works() -> None:
     good_fit = cirq.experiments.T1DecayResult(
         data=pd.DataFrame(
             columns=['delay_ns', 'false_count', 'true_count'],
@@ -159,7 +161,7 @@ def test_curve_fit_plot_works():
 
 
 @pytest.mark.parametrize('t1', [200.0, 500.0, 700.0])
-def test_noise_model_continous(t1):
+def test_noise_model_continous(t1) -> None:
     class GradualDecay(cirq.NoiseModel):
         def __init__(self, t1: float):
             self.t1 = t1
@@ -193,7 +195,7 @@ def test_noise_model_continous(t1):
 
 
 @pytest.mark.parametrize('gamma', [0.01, 0.05, 0.1])
-def test_noise_model_discrete(gamma):
+def test_noise_model_discrete(gamma) -> None:
     results = cirq.experiments.t1_decay(
         sampler=cirq.DensityMatrixSimulator(
             noise=cirq.NoiseModel.from_noise_model_like(cirq.amplitude_damp(gamma))
@@ -212,7 +214,7 @@ def test_noise_model_discrete(gamma):
     np.testing.assert_allclose(probs, np.mean(probs), atol=0.2)
 
 
-def test_bad_args():
+def test_bad_args() -> None:
     with pytest.raises(ValueError, match='repetitions <= 0'):
         _ = cirq.experiments.t1_decay(
             sampler=cirq.Simulator(),
@@ -253,7 +255,7 @@ def test_bad_args():
         )
 
 
-def test_str():
+def test_str() -> None:
     result = cirq.experiments.T1DecayResult(
         data=pd.DataFrame(
             columns=['delay_ns', 'false_count', 'true_count'],

cirq/experiments/t2_decay_experiment.py

@@ -11,8 +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.
+
+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
@@ -35,17 +38,17 @@ _T2_COLUMNS = ['delay_ns', 0, 1]
 
 
 def t2_decay(
-    sampler: 'cirq.Sampler',
+    sampler: cirq.Sampler,
     *,
-    qubit: 'cirq.Qid',
-    experiment_type: 'ExperimentType' = ExperimentType.RAMSEY,
+    qubit: cirq.Qid,
+    experiment_type: ExperimentType = ExperimentType.RAMSEY,
     num_points: int,
-    max_delay: 'cirq.DURATION_LIKE',
-    min_delay: 'cirq.DURATION_LIKE' = None,
+    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
@@ -234,7 +237,7 @@ def _create_tabulation(measurements: pd.DataFrame) -> pd.DataFrame:
     return tabulation
 
 
-def _cpmg_circuit(qubit: 'cirq.Qid', delay_var: sympy.Symbol, max_pulses: int) -> 'cirq.Circuit':
+def _cpmg_circuit(qubit: cirq.Qid, delay_var: sympy.Symbol, max_pulses: int) -> cirq.Circuit:
     """Creates a CPMG circuit for a given qubit.
 
     The circuit will look like:
@@ -256,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
@@ -351,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:
@@ -392,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/t2_decay_experiment_test.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import pandas as pd
 import pytest
 import sympy

cirq/experiments/two_qubit_xeb.py

@@ -13,23 +13,26 @@
 # 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
 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
-import pandas as pd
 from matplotlib import pyplot as plt
 
 from cirq import ops, value, vis
 from cirq._compat import cached_method
 from cirq.experiments import random_quantum_circuit_generation as rqcg
 from cirq.experiments.qubit_characterizations import (
-    parallel_single_qubit_randomized_benchmarking,
+    parallel_single_qubit_rb,
     ParallelRandomizedBenchmarkingResult,
+    RBParameters,
 )
 from cirq.experiments.xeb_fitting import (
     benchmark_2q_xeb_fidelities,
@@ -42,25 +45,27 @@ from cirq.qis import noise_utils
 if TYPE_CHECKING:
     import multiprocessing
 
+    import pandas as pd
+
     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)
     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: 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.
 
 
@@ -103,17 +108,21 @@ 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)
+            }
         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:
+    def plot_heatmap(self, ax: plt.Axes | None = None, **plot_kwargs) -> plt.Axes:
         """plot the heatmap of XEB errors.
 
         Args:
@@ -127,7 +136,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 +148,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.
 
@@ -185,21 +190,21 @@ 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}
 
-    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:
@@ -219,7 +224,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 +247,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 +283,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 +294,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'.
@@ -311,7 +316,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.
 
@@ -325,7 +330,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'
@@ -339,7 +344,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:
@@ -393,21 +398,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: 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,
+    random_state: cirq.RANDOM_STATE_OR_SEED_LIKE = 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:
@@ -483,16 +488,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: 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,
+    random_state: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
+    ax: plt.Axes | None = None,
+    pairs: Sequence[tuple[cirq.GridQubit, cirq.GridQubit]] | None = None,
     batch_size: int = 9,
     tags: Sequence[Any] = (),
     **plot_kwargs,
@@ -540,18 +545,18 @@ def parallel_two_qubit_xeb(
 
 
 def run_rb_and_xeb(
-    sampler: 'cirq.Sampler',
-    qubits: Optional[Sequence['cirq.GridQubit']] = None,
+    sampler: cirq.Sampler,
+    qubits: Sequence[cirq.GridQubit] | None = 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: Sequence[tuple[cirq.GridQubit, cirq.GridQubit]] | None = None,
     batch_size: int = 9,
     tags: Sequence[Any] = (),
 ) -> InferredXEBResult:
@@ -582,12 +587,14 @@ def run_rb_and_xeb(
 
     qubits, pairs = qubits_and_pairs(sampler, qubits, pairs)
 
-    rb = parallel_single_qubit_randomized_benchmarking(
+    rb = parallel_single_qubit_rb(
         sampler=sampler,
         qubits=qubits,
-        repetitions=repetitions,
-        num_circuits=num_circuits,
-        num_clifford_range=num_clifford_range,
+        parameters=RBParameters(
+            num_circuits=num_circuits,
+            repetitions=repetitions,
+            num_clifford_range=num_clifford_range,
+        ),
     )
 
     xeb = parallel_two_qubit_xeb(

cirq/experiments/two_qubit_xeb_test.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.
+
 """Wraps Parallel Two Qubit XEB into a few convenience methods."""
+
+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
@@ -26,7 +30,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)
 
 
@@ -86,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,
@@ -158,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,
@@ -290,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,