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

cirq/experiments/random_quantum_circuit_generation.py

@@ -13,35 +13,24 @@
 # limitations under the License.
 """Code for generating random quantum circuits."""
 
+from __future__ import annotations
+
 import dataclasses
 import itertools
-from typing import (
-    Any,
-    Callable,
-    cast,
-    Container,
-    Dict,
-    Iterable,
-    Iterator,
-    List,
-    Optional,
-    Sequence,
-    Tuple,
-    TYPE_CHECKING,
-    Union,
-)
+from typing import Any, Callable, Container, Iterable, Iterator, Sequence, TYPE_CHECKING
 
-import networkx as nx
 import numpy as np
 
 from cirq import circuits, devices, ops, protocols, value
 from cirq._doc import document
 
 if TYPE_CHECKING:
+    import networkx as nx
+
     import cirq
 
-QidPairT = Tuple['cirq.Qid', 'cirq.Qid']
-GridQubitPairT = Tuple['cirq.GridQubit', 'cirq.GridQubit']
+QidPairT = tuple['cirq.Qid', 'cirq.Qid']
+GridQubitPairT = tuple['cirq.GridQubit', 'cirq.GridQubit']
 
 
 @dataclasses.dataclass(frozen=True)
@@ -114,7 +103,7 @@ class GridInteractionLayer(Container[GridQubitPairT]):
         pos = a.row % 2, (a.col - self.col_offset) % 2
         return pos == (0, 0) or pos == (1, self.stagger)
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ['col_offset', 'vertical', 'stagger'])
 
     def __repr__(self) -> str:
@@ -179,20 +168,20 @@ document(
 
 
 def random_rotations_between_two_qubit_circuit(
-    q0: 'cirq.Qid',
-    q1: 'cirq.Qid',
+    q0: cirq.Qid,
+    q1: cirq.Qid,
     depth: int,
     two_qubit_op_factory: Callable[
-        ['cirq.Qid', 'cirq.Qid', 'np.random.RandomState'], 'cirq.OP_TREE'
+        [cirq.Qid, cirq.Qid, np.random.RandomState], cirq.OP_TREE
     ] = lambda a, b, _: ops.CZPowGate()(a, b),
-    single_qubit_gates: Sequence['cirq.Gate'] = (
+    single_qubit_gates: Sequence[cirq.Gate] = (
         ops.X**0.5,
         ops.Y**0.5,
         ops.PhasedXPowGate(phase_exponent=0.25, exponent=0.5),
     ),
     add_final_single_qubit_layer: bool = True,
-    seed: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None,
-) -> 'cirq.Circuit':
+    seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
+) -> cirq.Circuit:
     """Generate a random two-qubit quantum circuit.
 
     This construction uses a similar structure to those in the paper
@@ -243,14 +232,14 @@ def random_rotations_between_two_qubit_circuit(
 
 def generate_library_of_2q_circuits(
     n_library_circuits: int,
-    two_qubit_gate: 'cirq.Gate',
+    two_qubit_gate: cirq.Gate,
     *,
     max_cycle_depth: int = 100,
-    q0: 'cirq.Qid' = devices.LineQubit(0),
-    q1: 'cirq.Qid' = devices.LineQubit(1),
-    random_state: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None,
+    q0: cirq.Qid = devices.LineQubit(0),
+    q1: cirq.Qid = devices.LineQubit(1),
+    random_state: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
     tags: Sequence[Any] = (),
-) -> List['cirq.Circuit']:
+) -> list[cirq.Circuit]:
     """Generate a library of two-qubit Circuits.
 
     For single-qubit gates, this uses PhasedXZGates where the axis-in-XY-plane is one
@@ -306,18 +295,18 @@ class CircuitLibraryCombination:
     `get_random_combinations_for_pairs`.
     """
 
-    layer: Optional[Any]
+    layer: Any | None
     combinations: np.ndarray
-    pairs: List[QidPairT]
+    pairs: list[QidPairT]
 
 
 def _get_random_combinations(
     n_library_circuits: int,
     n_combinations: int,
     *,
-    pair_gen: Iterator[Tuple[List[QidPairT], Any]],
-    random_state: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None,
-) -> List[CircuitLibraryCombination]:
+    pair_gen: Iterator[tuple[list[QidPairT], Any]],
+    random_state: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
+) -> list[CircuitLibraryCombination]:
     """For qubit pairs, prepare a set of combinations to efficiently sample
     parallel two-qubit XEB circuits.
 
@@ -366,8 +355,8 @@ def get_random_combinations_for_device(
     device_graph: nx.Graph,
     *,
     pattern: Sequence[GridInteractionLayer] = HALF_GRID_STAGGERED_PATTERN,
-    random_state: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None,
-) -> List[CircuitLibraryCombination]:
+    random_state: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
+) -> list[CircuitLibraryCombination]:
     """For a given device, prepare a set of combinations to efficiently sample
     parallel two-qubit XEB circuits.
 
@@ -419,9 +408,9 @@ def get_random_combinations_for_device(
 def get_random_combinations_for_pairs(
     n_library_circuits: int,
     n_combinations: int,
-    all_pairs: List[List[QidPairT]],
-    random_state: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None,
-) -> List[CircuitLibraryCombination]:
+    all_pairs: list[list[QidPairT]],
+    random_state: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
+) -> list[CircuitLibraryCombination]:
     """For an explicit nested list of pairs, prepare a set of combinations to efficiently sample
     parallel two-qubit XEB circuits.
 
@@ -460,26 +449,25 @@ def get_random_combinations_for_pairs(
     )
 
 
-def _pairs_from_moment(moment: 'cirq.Moment') -> List[QidPairT]:
+def _pairs_from_moment(moment: cirq.Moment) -> list[QidPairT]:
     """Helper function in `get_random_combinations_for_layer_circuit` pair generator.
 
     The moment should contain only two qubit operations, which define a list of qubit pairs.
     """
-    pairs: List[QidPairT] = []
+    pairs: list[QidPairT] = []
     for op in moment.operations:
         if len(op.qubits) != 2:
             raise ValueError("Layer circuit contains non-2-qubit operations.")
-        qpair = cast(QidPairT, op.qubits)
-        pairs.append(qpair)
+        pairs.append(op.qubits)
     return pairs
 
 
 def get_random_combinations_for_layer_circuit(
     n_library_circuits: int,
     n_combinations: int,
-    layer_circuit: 'cirq.Circuit',
-    random_state: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None,
-) -> List[CircuitLibraryCombination]:
+    layer_circuit: cirq.Circuit,
+    random_state: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
+) -> list[CircuitLibraryCombination]:
     """For a layer circuit, prepare a set of combinations to efficiently sample
     parallel two-qubit XEB circuits.
 
@@ -523,7 +511,7 @@ def get_grid_interaction_layer_circuit(
     device_graph: nx.Graph,
     pattern: Sequence[GridInteractionLayer] = HALF_GRID_STAGGERED_PATTERN,
     two_qubit_gate=ops.ISWAP**0.5,
-) -> 'cirq.Circuit':
+) -> cirq.Circuit:
     """Create a circuit representation of a grid interaction pattern on a given device topology.
 
     The resulting circuit is deterministic, of depth len(pattern), and consists of `two_qubit_gate`
@@ -547,21 +535,21 @@ def get_grid_interaction_layer_circuit(
 
 
 def random_rotations_between_grid_interaction_layers_circuit(
-    qubits: Iterable['cirq.GridQubit'],
+    qubits: Iterable[cirq.GridQubit],
     depth: int,
     *,  # forces keyword arguments
     two_qubit_op_factory: Callable[
-        ['cirq.GridQubit', 'cirq.GridQubit', 'np.random.RandomState'], 'cirq.OP_TREE'
+        [cirq.GridQubit, cirq.GridQubit, np.random.RandomState], cirq.OP_TREE
     ] = lambda a, b, _: ops.CZPowGate()(a, b),
     pattern: Sequence[GridInteractionLayer] = GRID_STAGGERED_PATTERN,
-    single_qubit_gates: Sequence['cirq.Gate'] = (
+    single_qubit_gates: Sequence[cirq.Gate] = (
         ops.X**0.5,
         ops.Y**0.5,
         ops.PhasedXPowGate(phase_exponent=0.25, exponent=0.5),
     ),
     add_final_single_qubit_layer: bool = True,
-    seed: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None,
-) -> 'cirq.Circuit':
+    seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
+) -> cirq.Circuit:
     """Generate a random quantum circuit of a particular form.
 
     This construction is based on the circuits used in the paper
@@ -619,12 +607,12 @@ def random_rotations_between_grid_interaction_layers_circuit(
     return circuit
 
 
-def _coupled_qubit_pairs(qubits: List['cirq.GridQubit']) -> List[GridQubitPairT]:
+def _coupled_qubit_pairs(qubits: list[cirq.GridQubit]) -> list[GridQubitPairT]:
     pairs = []
     qubit_set = set(qubits)
     for qubit in qubits:
 
-        def add_pair(neighbor: 'cirq.GridQubit'):
+        def add_pair(neighbor: cirq.GridQubit):
             if neighbor in qubit_set:
                 pairs.append((qubit, neighbor))
 
@@ -637,16 +625,16 @@ def _coupled_qubit_pairs(qubits: List['cirq.GridQubit']) -> List[GridQubitPairT]
 class _RandomSingleQubitLayerFactory:
     def __init__(
         self,
-        qubits: Sequence['cirq.Qid'],
-        single_qubit_gates: Sequence['cirq.Gate'],
-        prng: 'np.random.RandomState',
+        qubits: Sequence[cirq.Qid],
+        single_qubit_gates: Sequence[cirq.Gate],
+        prng: np.random.RandomState,
     ) -> None:
         self.qubits = qubits
         self.single_qubit_gates = single_qubit_gates
         self.prng = prng
 
-    def new_layer(self, previous_single_qubit_layer: 'cirq.Moment') -> 'cirq.Moment':
-        def random_gate(qubit: 'cirq.Qid') -> 'cirq.Gate':
+    def new_layer(self, previous_single_qubit_layer: cirq.Moment) -> cirq.Moment:
+        def random_gate(qubit: cirq.Qid) -> cirq.Gate:
             excluded_op = previous_single_qubit_layer.operation_at(qubit)
             excluded_gate = excluded_op.gate if excluded_op is not None else None
             g = self.single_qubit_gates[self.prng.randint(0, len(self.single_qubit_gates))]
@@ -658,20 +646,18 @@ class _RandomSingleQubitLayerFactory:
 
 
 class _FixedSingleQubitLayerFactory:
-    def __init__(self, fixed_single_qubit_layer: Dict['cirq.Qid', 'cirq.Gate']) -> None:
+    def __init__(self, fixed_single_qubit_layer: dict[cirq.Qid, cirq.Gate]) -> None:
         self.fixed_single_qubit_layer = fixed_single_qubit_layer
 
-    def new_layer(self, previous_single_qubit_layer: 'cirq.Moment') -> 'cirq.Moment':
+    def new_layer(self, previous_single_qubit_layer: cirq.Moment) -> cirq.Moment:
         return circuits.Moment(v.on(q) for q, v in self.fixed_single_qubit_layer.items())
 
 
-_SingleQubitLayerFactory = Union[_FixedSingleQubitLayerFactory, _RandomSingleQubitLayerFactory]
+_SingleQubitLayerFactory = _FixedSingleQubitLayerFactory | _RandomSingleQubitLayerFactory
 
 
 def _single_qubit_gates_arg_to_factory(
-    single_qubit_gates: Sequence['cirq.Gate'],
-    qubits: Sequence['cirq.Qid'],
-    prng: 'np.random.RandomState',
+    single_qubit_gates: Sequence[cirq.Gate], qubits: Sequence[cirq.Qid], prng: np.random.RandomState
 ) -> _SingleQubitLayerFactory:
     """Parse the `single_qubit_gates` argument for circuit generation functions.
 
@@ -686,13 +672,13 @@ def _single_qubit_gates_arg_to_factory(
 
 
 def _two_qubit_layer(
-    coupled_qubit_pairs: List[GridQubitPairT],
+    coupled_qubit_pairs: list[GridQubitPairT],
     two_qubit_op_factory: Callable[
-        ['cirq.GridQubit', 'cirq.GridQubit', 'np.random.RandomState'], 'cirq.OP_TREE'
+        [cirq.GridQubit, cirq.GridQubit, np.random.RandomState], cirq.OP_TREE
     ],
     layer: GridInteractionLayer,
-    prng: 'np.random.RandomState',
-) -> Iterator['cirq.OP_TREE']:
+    prng: np.random.RandomState,
+) -> Iterator[cirq.OP_TREE]:
     for a, b in coupled_qubit_pairs:
         if (a, b) in layer or (b, a) in layer:
             yield two_qubit_op_factory(a, b, prng)

cirq/experiments/random_quantum_circuit_generation_test.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 itertools
-from typing import Callable, cast, Dict, Iterable, List, Optional, Sequence, Set, Tuple
+from typing import Callable, cast, Iterable, Sequence
 
 import networkx as nx
 import numpy as np
@@ -32,7 +35,7 @@ from cirq.experiments.random_quantum_circuit_generation import (
     random_rotations_between_two_qubit_circuit,
 )
 
-SINGLE_QUBIT_LAYER = Dict[cirq.GridQubit, Optional[cirq.Gate]]
+SINGLE_QUBIT_LAYER = dict[cirq.GridQubit, cirq.Gate | None]
 
 
 def test_random_rotation_between_two_qubit_circuit():
@@ -366,7 +369,7 @@ def test_random_rotations_between_grid_interaction_layers(
     pattern: Sequence[GridInteractionLayer],
     single_qubit_gates: Sequence[cirq.Gate],
     add_final_single_qubit_layer: bool,
-    seed: 'cirq.RANDOM_STATE_OR_SEED_LIKE',
+    seed: cirq.RANDOM_STATE_OR_SEED_LIKE,
     expected_circuit_length: int,
     single_qubit_layers_slice: slice,
     two_qubit_layers_slice: slice,
@@ -401,7 +404,7 @@ def test_grid_interaction_layer_repr():
 
 
 def _validate_single_qubit_layers(
-    qubits: Set[cirq.GridQubit], moments: Sequence[cirq.Moment], non_repeating_layers: bool = True
+    qubits: set[cirq.GridQubit], moments: Sequence[cirq.Moment], non_repeating_layers: bool = True
 ) -> None:
     previous_single_qubit_gates: SINGLE_QUBIT_LAYER = {q: None for q in qubits}
 
@@ -419,7 +422,7 @@ def _validate_single_qubit_layers(
 
 
 def _validate_two_qubit_layers(
-    qubits: Set[cirq.GridQubit],
+    qubits: set[cirq.GridQubit],
     moments: Sequence[cirq.Moment],
     pattern: Sequence[cirq.experiments.GridInteractionLayer],
 ) -> None:
@@ -444,12 +447,12 @@ def _validate_two_qubit_layers(
 
 
 def _coupled_qubit_pairs(
-    qubits: Set['cirq.GridQubit'],
-) -> List[Tuple['cirq.GridQubit', 'cirq.GridQubit']]:
+    qubits: set[cirq.GridQubit],
+) -> list[tuple[cirq.GridQubit, cirq.GridQubit]]:
     pairs = []
     for qubit in qubits:
 
-        def add_pair(neighbor: 'cirq.GridQubit'):
+        def add_pair(neighbor: cirq.GridQubit):
             if neighbor in qubits:
                 pairs.append((qubit, neighbor))
 

cirq/experiments/readout_confusion_matrix.py

@@ -14,8 +14,10 @@
 
 """Utilities to compute readout confusion matrix and use it for readout error mitigation."""
 
+from __future__ import annotations
+
 import time
-from typing import Any, cast, Dict, List, Optional, Sequence, Tuple, TYPE_CHECKING, Union
+from typing import Any, cast, Sequence, TYPE_CHECKING
 
 import numpy as np
 import scipy.optimize
@@ -59,8 +61,8 @@ class TensoredConfusionMatrices:
 
     def __init__(
         self,
-        confusion_matrices: Union[np.ndarray, Sequence[np.ndarray]],
-        measure_qubits: Union[Sequence['cirq.Qid'], Sequence[Sequence['cirq.Qid']]],
+        confusion_matrices: np.ndarray | Sequence[np.ndarray],
+        measure_qubits: Sequence[cirq.Qid] | Sequence[Sequence[cirq.Qid]],
         *,
         repetitions: int,
         timestamp: float,
@@ -112,14 +114,14 @@ class TensoredConfusionMatrices:
         self._measure_qubits = tuple(tuple(q) for q in measure_qubits)
         self._qubits = tuple(sorted(set(q for ql in measure_qubits for q in ql)))
         self._qubits_to_idx = {q: i for i, q in enumerate(self._qubits)}
-        self._cache: Dict[Tuple['cirq.Qid', ...], np.ndarray] = {}
+        self._cache: dict[tuple[cirq.Qid, ...], np.ndarray] = {}
         if sum(len(q) for q in self._measure_qubits) != len(self._qubits):
             raise ValueError(f"Repeated qubits not allowed in measure_qubits: {measure_qubits}.")
 
     @classmethod
     def from_measurement(
-        cls, gate: ops.MeasurementGate, qubits: Sequence['cirq.Qid']
-    ) -> 'TensoredConfusionMatrices':
+        cls, gate: ops.MeasurementGate, qubits: Sequence[cirq.Qid]
+    ) -> TensoredConfusionMatrices:
         """Generates TCM for the confusion map in a MeasurementGate.
 
         This ignores any invert_mask defined for the gate - it only replicates the confusion map.
@@ -155,27 +157,27 @@ class TensoredConfusionMatrices:
         return self._timestamp
 
     @property
-    def confusion_matrices(self) -> Tuple[np.ndarray, ...]:
+    def confusion_matrices(self) -> tuple[np.ndarray, ...]:
         """List of confusion matrices corresponding to `measure_qubits` qubit pattern."""
         return self._confusion_matrices
 
     @property
-    def measure_qubits(self) -> Tuple[Tuple['cirq.Qid', ...], ...]:
+    def measure_qubits(self) -> tuple[tuple[cirq.Qid, ...], ...]:
         """Calibrated qubit pattern for which individual confusion matrices were computed."""
         return self._measure_qubits
 
     @property
-    def qubits(self) -> Tuple['cirq.Qid', ...]:
+    def qubits(self) -> tuple[cirq.Qid, ...]:
         """Sorted list of all calibrated qubits."""
         return self._qubits
 
-    def _get_vars(self, qubit_pattern: Sequence['cirq.Qid']) -> List[int]:
+    def _get_vars(self, qubit_pattern: Sequence[cirq.Qid]) -> list[int]:
         in_vars = [2 * self._qubits_to_idx[q] for q in qubit_pattern]
         out_vars = [2 * self._qubits_to_idx[q] + 1 for q in qubit_pattern]
         return in_vars + out_vars
 
-    def _confusion_matrix(self, qubits: Sequence['cirq.Qid']) -> np.ndarray:
-        ein_input: List[np.ndarray | List[int]] = []
+    def _confusion_matrix(self, qubits: Sequence[cirq.Qid]) -> np.ndarray:
+        ein_input: list[np.ndarray | list[int]] = []
         for qs, cm in zip(self.measure_qubits, self.confusion_matrices):
             ein_input.extend([cm.reshape((2, 2) * len(qs)), self._get_vars(qs)])
         ein_out = self._get_vars(qubits)
@@ -183,7 +185,7 @@ class TensoredConfusionMatrices:
         ret = np.einsum(*ein_input, ein_out).reshape((2 ** len(qubits),) * 2)
         return ret / ret.sum(axis=1)
 
-    def confusion_matrix(self, qubits: Optional[Sequence['cirq.Qid']] = None) -> np.ndarray:
+    def confusion_matrix(self, qubits: Sequence[cirq.Qid] | None = None) -> np.ndarray:
         """Returns a single confusion matrix constructed for the given set of qubits.
 
         The single `2 ** len(qubits) x 2 ** len(qubits)` confusion matrix is constructed
@@ -211,7 +213,7 @@ class TensoredConfusionMatrices:
             self._cache[key] = self._confusion_matrix(qubits)
         return self._cache[key]
 
-    def correction_matrix(self, qubits: Optional[Sequence['cirq.Qid']] = None) -> np.ndarray:
+    def correction_matrix(self, qubits: Sequence[cirq.Qid] | None = None) -> np.ndarray:
         """Returns a single correction matrix constructed for the given set of qubits.
 
         A correction matrix is the inverse of confusion matrix and can be used to apply corrections
@@ -240,7 +242,7 @@ class TensoredConfusionMatrices:
     def apply(
         self,
         result: np.ndarray,
-        qubits: Optional[Sequence['cirq.Qid']] = None,
+        qubits: Sequence[cirq.Qid] | None = None,
         *,
         method='least_squares',
     ) -> np.ndarray:
@@ -300,7 +302,7 @@ class TensoredConfusionMatrices:
         return res.x
 
     def readout_mitigation_pauli_uncorrelated(
-        self, qubits: Sequence['cirq.Qid'], measured_bitstrings: np.ndarray
+        self, qubits: Sequence[cirq.Qid], measured_bitstrings: np.ndarray
     ) -> tuple[float, float]:
         r"""Uncorrelated readout error mitigation for a multi-qubit Pauli operator.
 
@@ -345,8 +347,8 @@ class TensoredConfusionMatrices:
                 idx = self.measure_qubits.index((qubit,))
             except:  # pragma: no cover
                 raise NotImplementedError(
-                    "The response matrix must be a tensor product of single-qu"
-                    + f"bit response matrices, including that of qubit {qubit}."
+                    "The response matrix must be a tensor product of single-qubit "
+                    f"response matrices, including that of qubit {qubit}."
                 )
             cm_all.append(self.confusion_matrices[idx])
 
@@ -373,7 +375,7 @@ class TensoredConfusionMatrices:
             f")"
         )
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return {
             'confusion_matrices': self.confusion_matrices,
             'measure_qubits': self.measure_qubits,
@@ -384,7 +386,7 @@ class TensoredConfusionMatrices:
     @classmethod
     def _from_json_dict_(
         cls, confusion_matrices, measure_qubits, repetitions, timestamp, **kwargs
-    ) -> 'TensoredConfusionMatrices':
+    ) -> TensoredConfusionMatrices:
         return cls(
             [np.asarray(cm) for cm in confusion_matrices],
             measure_qubits,
@@ -423,8 +425,8 @@ class TensoredConfusionMatrices:
 
 
 def measure_confusion_matrix(
-    sampler: 'cirq.Sampler',
-    qubits: Union[Sequence['cirq.Qid'], Sequence[Sequence['cirq.Qid']]],
+    sampler: cirq.Sampler,
+    qubits: Sequence[cirq.Qid] | Sequence[Sequence[cirq.Qid]],
     repetitions: int = 1000,
 ) -> TensoredConfusionMatrices:
     """Prepares `TensoredConfusionMatrices` for the n qubits in the input.

cirq/experiments/readout_confusion_matrix_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 pytest
 

cirq/experiments/single_qubit_readout_calibration.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.
+
 """Single qubit readout experiments using parallel or isolated statistics."""
+
+from __future__ import annotations
+
 import dataclasses
 import time
-from typing import Any, cast, Dict, Iterable, List, Optional, TYPE_CHECKING
+from typing import Any, cast, Iterable, TYPE_CHECKING
 
 import matplotlib.pyplot as plt
 import numpy as np
@@ -43,12 +47,12 @@ class SingleQubitReadoutCalibrationResult:
         timestamp: The time the data was taken, in seconds since the epoch.
     """
 
-    zero_state_errors: Dict['cirq.Qid', float]
-    one_state_errors: Dict['cirq.Qid', float]
+    zero_state_errors: dict[cirq.Qid, float]
+    one_state_errors: dict[cirq.Qid, float]
     repetitions: int
     timestamp: float
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return {
             'zero_state_errors': list(self.zero_state_errors.items()),
             'one_state_errors': list(self.one_state_errors.items()),
@@ -58,7 +62,7 @@ class SingleQubitReadoutCalibrationResult:
 
     def plot_heatmap(
         self,
-        axs: Optional[tuple[plt.Axes, plt.Axes]] = None,
+        axs: tuple[plt.Axes, plt.Axes] | None = None,
         annotation_format: str = '0.1%',
         **plot_kwargs: Any,
     ) -> tuple[plt.Axes, plt.Axes]:
@@ -106,16 +110,16 @@ class SingleQubitReadoutCalibrationResult:
 
     def plot_integrated_histogram(
         self,
-        ax: Optional[plt.Axes] = None,
+        ax: plt.Axes | None = None,
         cdf_on_x: bool = False,
         axis_label: str = 'Readout error rate',
         semilog: bool = True,
         median_line: bool = True,
-        median_label: Optional[str] = 'median',
+        median_label: str | None = 'median',
         mean_line: bool = False,
-        mean_label: Optional[str] = 'mean',
+        mean_label: str | None = 'mean',
         show_zero: bool = False,
-        title: Optional[str] = None,
+        title: str | None = None,
         **kwargs,
     ) -> plt.Axes:
         """Plot the readout errors using cirq.integrated_histogram().
@@ -175,6 +179,17 @@ class SingleQubitReadoutCalibrationResult:
         ax.set_ylabel('Percentile')
         return ax
 
+    def readout_result_for_qubits(
+        self, readout_qubits: list[ops.Qid]
+    ) -> SingleQubitReadoutCalibrationResult:
+        """Builds a calibration result for the specific readout qubits."""
+        return SingleQubitReadoutCalibrationResult(
+            zero_state_errors={qubit: self.zero_state_errors[qubit] for qubit in readout_qubits},
+            one_state_errors={qubit: self.one_state_errors[qubit] for qubit in readout_qubits},
+            timestamp=self.timestamp,
+            repetitions=self.repetitions,
+        )
+
     @classmethod
     def _from_json_dict_(
         cls, zero_state_errors, one_state_errors, repetitions, timestamp, **kwargs
@@ -197,7 +212,7 @@ class SingleQubitReadoutCalibrationResult:
 
 
 def estimate_single_qubit_readout_errors(
-    sampler: 'cirq.Sampler', *, qubits: Iterable['cirq.Qid'], repetitions: int = 1000
+    sampler: cirq.Sampler, *, qubits: Iterable[cirq.Qid], repetitions: int = 1000
 ) -> SingleQubitReadoutCalibrationResult:
     """Estimate single-qubit readout error.
 
@@ -229,13 +244,13 @@ def estimate_single_qubit_readout_errors(
 
 
 def estimate_parallel_single_qubit_readout_errors(
-    sampler: 'cirq.Sampler',
+    sampler: cirq.Sampler,
     *,
-    qubits: Iterable['cirq.Qid'],
+    qubits: Iterable[cirq.Qid],
     trials: int = 20,
     repetitions: int = 1000,
-    trials_per_batch: Optional[int] = None,
-    bit_strings: Optional[np.ndarray] = None,
+    trials_per_batch: int | None = None,
+    bit_strings: np.ndarray | None = None,
 ) -> SingleQubitReadoutCalibrationResult:
     """Estimate single qubit readout error using parallel operations.
 
@@ -296,7 +311,7 @@ def estimate_parallel_single_qubit_readout_errors(
     if trials_per_batch <= 0:
         raise ValueError("Must provide non-zero trials_per_batch for readout calibration.")
 
-    all_sweeps: List[study.Sweepable] = []
+    all_sweeps: list[study.Sweepable] = []
     num_batches = (trials + trials_per_batch - 1) // trials_per_batch
 
     # Initialize circuits

cirq/experiments/single_qubit_readout_calibration_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
+
 from typing import Sequence
 
 import numpy as np
@@ -30,7 +33,7 @@ def test_single_qubit_readout_result_repr():
 
 
 class NoisySingleQubitReadoutSampler(cirq.Sampler):
-    def __init__(self, p0: float, p1: float, seed: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None):
+    def __init__(self, p0: float, p1: float, seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None):
         """Sampler that flips some bits upon readout.
 
         Args:
@@ -44,7 +47,7 @@ class NoisySingleQubitReadoutSampler(cirq.Sampler):
         self.simulator = cirq.Simulator(seed=self.prng, split_untangled_states=False)
 
     def run_sweep(
-        self, program: 'cirq.AbstractCircuit', params: cirq.Sweepable, repetitions: int = 1
+        self, program: cirq.AbstractCircuit, params: cirq.Sweepable, repetitions: int = 1
     ) -> Sequence[cirq.Result]:
         results = self.simulator.run_sweep(program, params, repetitions)
         for result in results: