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

cirq/work/observable_measurement.py

@@ -20,19 +20,7 @@ import itertools
 import os
 import tempfile
 import warnings
-from typing import (
-    Any,
-    Dict,
-    Iterable,
-    List,
-    Mapping,
-    Optional,
-    Sequence,
-    Set,
-    Tuple,
-    TYPE_CHECKING,
-    Union,
-)
+from typing import Any, Iterable, Mapping, Sequence, TYPE_CHECKING
 
 import numpy as np
 import pandas as pd
@@ -150,7 +138,7 @@ class RepetitionsStoppingCriteria(StoppingCriteria):
         return protocols.dataclass_json_dict(self)
 
 
-_OBS_TO_PARAM_VAL: Dict[Tuple[cirq.Pauli, bool], Tuple[float, float]] = {
+_OBS_TO_PARAM_VAL: dict[tuple[cirq.Pauli, bool], tuple[float, float]] = {
     (ops.X, False): (0, -1 / 2),
     (ops.X, True): (0, +1 / 2),
     (ops.Y, False): (1 / 2, 0),
@@ -162,7 +150,7 @@ _OBS_TO_PARAM_VAL: Dict[Tuple[cirq.Pauli, bool], Tuple[float, float]] = {
 second element in the key is whether to measure in the positive or negative (flipped) basis
 for readout symmetrization."""
 
-_STATE_TO_PARAM_VAL: Dict[_NamedOneQubitState, Tuple[float, float]] = {
+_STATE_TO_PARAM_VAL: dict[_NamedOneQubitState, tuple[float, float]] = {
     value.KET_PLUS: (0, +1 / 2),
     value.KET_MINUS: (0, -1 / 2),
     value.KET_IMAG: (-1 / 2, 0),
@@ -178,7 +166,7 @@ def _get_params_for_setting(
     flips: Iterable[bool],
     qubits: Sequence[cirq.Qid],
     needs_init_layer: bool,
-) -> Dict[str, float]:
+) -> dict[str, float]:
     """Return the parameter dictionary for the given setting.
 
     This must be used in conjunction with a circuit generated by
@@ -241,7 +229,7 @@ def _pad_setting(
     return InitObsSetting(init_state=init_state, observable=obs)
 
 
-def _aggregate_n_repetitions(next_chunk_repetitions: Set[int]) -> int:
+def _aggregate_n_repetitions(next_chunk_repetitions: set[int]) -> int:
     """A stopping criteria can request a different number of more_repetitions for each
     measurement spec. For batching efficiency, we take the max and issue a warning in this case."""
     if len(next_chunk_repetitions) == 1:
@@ -257,10 +245,10 @@ def _aggregate_n_repetitions(next_chunk_repetitions: Set[int]) -> int:
 
 
 def _check_meas_specs_still_todo(
-    meas_specs: List[_MeasurementSpec],
+    meas_specs: list[_MeasurementSpec],
     accumulators: Mapping[_MeasurementSpec, BitstringAccumulator],
     stopping_criteria: StoppingCriteria,
-) -> Tuple[List[_MeasurementSpec], int]:
+) -> tuple[list[_MeasurementSpec], int]:
     """Filter `meas_specs` in case some are done.
 
     In the sampling loop in `measure_grouped_settings`, we submit
@@ -268,7 +256,7 @@ def _check_meas_specs_still_todo(
     removing `meas_spec`s from the loop if they are done.
     """
     still_todo = []
-    repetitions_set: Set[int] = set()
+    repetitions_set: set[int] = set()
     for meas_spec in meas_specs:
         accumulator = accumulators[meas_spec]
         more_repetitions = stopping_criteria.more_repetitions(accumulator)
@@ -334,7 +322,7 @@ def _subdivide_meas_specs(
     repetitions: int,
     qubits: Sequence[cirq.Qid],
     readout_symmetrization: bool,
-) -> Tuple[List[_FlippyMeasSpec], int]:
+) -> tuple[list[_FlippyMeasSpec], int]:
     """Split measurement specs into sub-jobs for readout symmetrization
 
     In readout symmetrization, we first run the "normal" circuit followed
@@ -368,8 +356,8 @@ def _to_sweep(param_tuples):
 
 
 def _parse_checkpoint_options(
-    checkpoint: bool, checkpoint_fn: Optional[str], checkpoint_other_fn: Optional[str]
-) -> Tuple[Optional[str], Optional[str]]:
+    checkpoint: bool, checkpoint_fn: str | None, checkpoint_other_fn: str | None
+) -> tuple[str | None, str | None]:
     """Parse the checkpoint-oriented options in `measure_grouped_settings`.
 
     This function contains the validation and defaults logic. Please see
@@ -447,8 +435,8 @@ class CheckpointFileOptions:
     """
 
     checkpoint: bool = False
-    checkpoint_fn: Optional[str] = None
-    checkpoint_other_fn: Optional[str] = None
+    checkpoint_fn: str | None = None
+    checkpoint_other_fn: str | None = None
 
     def __post_init__(self):
         fn, other_fn = _parse_checkpoint_options(
@@ -472,7 +460,7 @@ class CheckpointFileOptions:
         protocols.to_json(obj, self.checkpoint_fn)
 
 
-def _needs_init_layer(grouped_settings: Dict[InitObsSetting, List[InitObsSetting]]) -> bool:
+def _needs_init_layer(grouped_settings: dict[InitObsSetting, list[InitObsSetting]]) -> bool:
     """Helper function to go through init_states and determine if any of them need an
     initialization layer of single-qubit gates."""
     for max_setting in grouped_settings.keys():
@@ -483,15 +471,15 @@ def _needs_init_layer(grouped_settings: Dict[InitObsSetting, List[InitObsSetting
 
 def measure_grouped_settings(
     circuit: cirq.AbstractCircuit,
-    grouped_settings: Dict[InitObsSetting, List[InitObsSetting]],
+    grouped_settings: dict[InitObsSetting, list[InitObsSetting]],
     sampler: cirq.Sampler,
     stopping_criteria: StoppingCriteria,
     *,
     readout_symmetrization: bool = False,
     circuit_sweep: cirq.Sweepable = None,
-    readout_calibrations: Optional[BitstringAccumulator] = None,
+    readout_calibrations: BitstringAccumulator | None = None,
     checkpoint: CheckpointFileOptions = CheckpointFileOptions(),
-) -> List[BitstringAccumulator]:
+) -> list[BitstringAccumulator]:
     """Measure a suite of grouped InitObsSetting settings.
 
     This is a low-level API for accessing the observable measurement
@@ -596,10 +584,10 @@ def measure_grouped_settings(
     return list(accumulators.values())
 
 
-_GROUPING_FUNCS: Dict[str, GROUPER_T] = {'greedy': group_settings_greedy}
+_GROUPING_FUNCS: dict[str, GROUPER_T] = {'greedy': group_settings_greedy}
 
 
-def _parse_grouper(grouper: Union[str, GROUPER_T] = group_settings_greedy) -> GROUPER_T:
+def _parse_grouper(grouper: str | GROUPER_T = group_settings_greedy) -> GROUPER_T:
     """Logic for turning a named grouper into one of the build-in groupers in support of the
     high-level `measure_observables` API."""
     if isinstance(grouper, str):
@@ -612,7 +600,7 @@ def _parse_grouper(grouper: Union[str, GROUPER_T] = group_settings_greedy) -> GR
 
 def _get_all_qubits(
     circuit: cirq.AbstractCircuit, observables: Iterable[cirq.PauliString]
-) -> List[cirq.Qid]:
+) -> list[cirq.Qid]:
     """Helper function for `measure_observables` to get all qubits from a circuit and a
     collection of observables."""
     qubit_set = set()
@@ -625,15 +613,15 @@ def _get_all_qubits(
 def measure_observables(
     circuit: cirq.AbstractCircuit,
     observables: Iterable[cirq.PauliString],
-    sampler: Union[cirq.Simulator, cirq.Sampler],
+    sampler: cirq.Simulator | cirq.Sampler,
     stopping_criteria: StoppingCriteria,
     *,
     readout_symmetrization: bool = False,
-    circuit_sweep: Optional[cirq.Sweepable] = None,
-    grouper: Union[str, GROUPER_T] = group_settings_greedy,
-    readout_calibrations: Optional[BitstringAccumulator] = None,
+    circuit_sweep: cirq.Sweepable | None = None,
+    grouper: str | GROUPER_T = group_settings_greedy,
+    readout_calibrations: BitstringAccumulator | None = None,
     checkpoint: CheckpointFileOptions = CheckpointFileOptions(),
-) -> List[ObservableMeasuredResult]:
+) -> list[ObservableMeasuredResult]:
     """Measure a collection of PauliString observables for a state prepared by a Circuit.
 
     If you need more control over the process, please see `measure_grouped_settings` for a
@@ -687,13 +675,13 @@ def measure_observables(
 def measure_observables_df(
     circuit: cirq.AbstractCircuit,
     observables: Iterable[cirq.PauliString],
-    sampler: Union[cirq.Simulator, cirq.Sampler],
+    sampler: cirq.Simulator | cirq.Sampler,
     stopping_criteria: StoppingCriteria,
     *,
     readout_symmetrization: bool = False,
-    circuit_sweep: Optional[cirq.Sweepable] = None,
-    grouper: Union[str, GROUPER_T] = group_settings_greedy,
-    readout_calibrations: Optional[BitstringAccumulator] = None,
+    circuit_sweep: cirq.Sweepable | None = None,
+    grouper: str | GROUPER_T = group_settings_greedy,
+    readout_calibrations: BitstringAccumulator | None = None,
     checkpoint: CheckpointFileOptions = CheckpointFileOptions(),
 ):
     """Measure observables and return resulting data as a Pandas dataframe.

cirq/work/observable_measurement_data.py

@@ -16,7 +16,7 @@ from __future__ import annotations
 
 import dataclasses
 import datetime
-from typing import Any, Dict, Iterable, List, Mapping, Optional, Tuple, TYPE_CHECKING, Union
+from typing import Any, Iterable, Mapping, TYPE_CHECKING
 
 import numpy as np
 import sympy
@@ -66,7 +66,7 @@ def _stats_from_measurements(
     qubit_to_index: Mapping[cirq.Qid, int],
     observable: cirq.PauliString,
     atol: float,
-) -> Tuple[float, float]:
+) -> tuple[float, float]:
     """Return the mean and squared standard error of the mean for the given
     observable according to the measurements in `bitstrings`."""
     obs_vals = _obs_vals_from_measurements(bitstrings, qubit_to_index, observable, atol=atol)
@@ -109,7 +109,7 @@ class ObservableMeasuredResult:
     mean: float
     variance: float
     repetitions: int
-    circuit_params: Mapping[Union[str, sympy.Expr], Union[value.Scalar, sympy.Expr]]
+    circuit_params: Mapping[str | sympy.Expr, value.Scalar | sympy.Expr]
 
     # unhashable because of the mapping-type circuit_params attribute
     __hash__ = None  # type: ignore
@@ -138,7 +138,7 @@ class ObservableMeasuredResult:
     def stddev(self):
         return np.sqrt(self.variance)
 
-    def as_dict(self) -> Dict[str, Any]:
+    def as_dict(self) -> dict[str, Any]:
         """Return the contents of this class as a dictionary.
 
         This makes records suitable for construction of a Pandas dataframe. The circuit parameters
@@ -215,32 +215,32 @@ class BitstringAccumulator:
     def __init__(
         self,
         meas_spec: _MeasurementSpec,
-        simul_settings: List[InitObsSetting],
+        simul_settings: list[InitObsSetting],
         qubit_to_index: Mapping[cirq.Qid, int],
-        bitstrings: Optional[np.ndarray] = None,
-        chunksizes: Optional[np.ndarray] = None,
-        timestamps: Optional[np.ndarray] = None,
-        readout_calibration: Optional[BitstringAccumulator] = None,
+        bitstrings: np.ndarray | None = None,
+        chunksizes: np.ndarray | None = None,
+        timestamps: np.ndarray | None = None,
+        readout_calibration: BitstringAccumulator | None = None,
     ):
         self._meas_spec = meas_spec
         self._simul_settings = simul_settings
         self._qubit_to_index = qubit_to_index
         self._readout_calibration = readout_calibration
 
-        self.bitstrings: np.ndarray[Tuple[int, ...], np.dtype[np.uint8]]
+        self.bitstrings: np.ndarray[tuple[int, ...], np.dtype[np.uint8]]
         if bitstrings is None:
             n_bits = len(qubit_to_index)
             self.bitstrings = np.zeros((0, n_bits), dtype=np.uint8)
         else:
             self.bitstrings = np.asarray(bitstrings, dtype=np.uint8)
 
-        self.chunksizes: np.ndarray[Tuple[int, ...], np.dtype[np.int64]]
+        self.chunksizes: np.ndarray[tuple[int, ...], np.dtype[np.int64]]
         if chunksizes is None:
             self.chunksizes = np.zeros((0,), dtype=np.int64)
         else:
             self.chunksizes = np.asarray(chunksizes, dtype=np.int64)
 
-        self.timestamps: np.ndarray[Tuple[int, ...], np.dtype[np.datetime64]]
+        self.timestamps: np.ndarray[tuple[int, ...], np.dtype[np.datetime64]]
         if timestamps is None:
             self.timestamps = np.zeros((0,), dtype='datetime64[us]')
         else:
@@ -528,8 +528,8 @@ class BitstringAccumulator:
 
 
 def flatten_grouped_results(
-    grouped_results: List[BitstringAccumulator],
-) -> List[ObservableMeasuredResult]:
+    grouped_results: list[BitstringAccumulator],
+) -> list[ObservableMeasuredResult]:
     """Flatten a collection of BitstringAccumulators into a list of ObservableMeasuredResult.
 
     Raw results are contained in BitstringAccumulator which contains

cirq/work/observable_measurement_test.py

@@ -15,7 +15,7 @@
 from __future__ import annotations
 
 import tempfile
-from typing import Dict, Iterable, List
+from typing import Iterable
 
 import numpy as np
 import pytest
@@ -529,7 +529,7 @@ def test_XYZ_point8(circuit, observable) -> None:
 
 def _each_in_its_own_group_grouper(
     settings: Iterable[InitObsSetting],
-) -> Dict[InitObsSetting, List[InitObsSetting]]:
+) -> dict[InitObsSetting, list[InitObsSetting]]:
     return {setting: [setting] for setting in settings}
 
 

cirq/work/observable_settings.py

@@ -16,7 +16,7 @@ from __future__ import annotations
 
 import dataclasses
 import numbers
-from typing import Dict, FrozenSet, Iterable, Mapping, Optional, Tuple, TYPE_CHECKING, Union
+from typing import Iterable, Mapping, TYPE_CHECKING
 
 import sympy
 
@@ -64,7 +64,7 @@ class InitObsSetting:
         return protocols.dataclass_json_dict(self)
 
 
-def _max_weight_observable(observables: Iterable[ops.PauliString]) -> Optional[ops.PauliString]:
+def _max_weight_observable(observables: Iterable[ops.PauliString]) -> ops.PauliString | None:
     """Create a new observable that is compatible with all input observables
     and has the maximum non-identity elements.
 
@@ -80,7 +80,7 @@ def _max_weight_observable(observables: Iterable[ops.PauliString]) -> Optional[o
     The returned value need not actually be present in the input observables.
     Coefficients from input observables will be dropped.
     """
-    qubit_pauli_map: Dict[ops.Qid, ops.Pauli] = {}
+    qubit_pauli_map: dict[ops.Qid, ops.Pauli] = {}
     for observable in observables:
         for qubit, pauli in observable.items():
             if qubit in qubit_pauli_map:
@@ -91,7 +91,7 @@ def _max_weight_observable(observables: Iterable[ops.PauliString]) -> Optional[o
     return ops.PauliString(qubit_pauli_map)
 
 
-def _max_weight_state(states: Iterable[value.ProductState]) -> Optional[value.ProductState]:
+def _max_weight_state(states: Iterable[value.ProductState]) -> value.ProductState | None:
     """Create a new state that is compatible with all input states
     and has the maximum weight.
 
@@ -104,7 +104,7 @@ def _max_weight_state(states: Iterable[value.ProductState]) -> Optional[value.Pr
     "+X(0) * -Z(1)". Asking for the max weight state of something like
     [+X(0), +Z(0)] will return None.
     """
-    qubit_state_map: Dict[ops.Qid, _NamedOneQubitState] = {}
+    qubit_state_map: dict[ops.Qid, _NamedOneQubitState] = {}
     for state in states:
         for qubit, named_state in state:
             if qubit in qubit_state_map:
@@ -130,7 +130,7 @@ def observables_to_settings(
         yield InitObsSetting(init_state=zeros_state(qubits), observable=observable)
 
 
-def _fix_precision(val: Union[value.Scalar, sympy.Expr], precision) -> Union[int, Tuple[int, int]]:
+def _fix_precision(val: value.Scalar | sympy.Expr, precision) -> int | tuple[int, int]:
     """Convert floating point or complex numbers to (implicitly) fixed point
     integers. Complex numbers will return fixed-point (real, imag) tuples.
 
@@ -146,9 +146,8 @@ def _fix_precision(val: Union[value.Scalar, sympy.Expr], precision) -> Union[int
 
 
 def _hashable_param(
-    param_tuples: Iterable[Tuple[Union[str, sympy.Expr], Union[value.Scalar, sympy.Expr]]],
-    precision=1e7,
-) -> FrozenSet[Tuple[str, Union[int, Tuple[int, int]]]]:
+    param_tuples: Iterable[tuple[str | sympy.Expr, value.Scalar | sympy.Expr]], precision=1e7
+) -> frozenset[tuple[str, int | tuple[int, int]]]:
     """Hash circuit parameters using fixed precision.
 
     Circuit parameters can be complex but we also need to use them as
@@ -170,7 +169,7 @@ class _MeasurementSpec:
     """
 
     max_setting: InitObsSetting
-    circuit_params: Mapping[Union[str, sympy.Expr], Union[value.Scalar, sympy.Expr]]
+    circuit_params: Mapping[str | sympy.Expr, value.Scalar | sympy.Expr]
 
     def __hash__(self):
         return hash((self.max_setting, _hashable_param(self.circuit_params.items())))

cirq/work/pauli_sum_collector.py

@@ -15,7 +15,7 @@
 from __future__ import annotations
 
 import collections
-from typing import cast, Dict, Optional, TYPE_CHECKING, Union
+from typing import cast, TYPE_CHECKING
 
 import numpy as np
 
@@ -60,12 +60,12 @@ class PauliSumCollector(collector.Collector):
             if not p:
                 self._identity_offset += p.coefficient
 
-        self._zeros: Dict[ops.PauliString, int] = collections.defaultdict(lambda: 0)
-        self._ones: Dict[ops.PauliString, int] = collections.defaultdict(lambda: 0)
+        self._zeros: dict[ops.PauliString, int] = collections.defaultdict(lambda: 0)
+        self._ones: dict[ops.PauliString, int] = collections.defaultdict(lambda: 0)
         self._samples_per_term = samples_per_term
         self._total_samples_requested = 0
 
-    def next_job(self) -> Optional[cirq.CircuitSampleJob]:
+    def next_job(self) -> cirq.CircuitSampleJob | None:
         i = self._total_samples_requested // self._samples_per_term
         if i >= len(self._pauli_coef_terms):
             return None
@@ -85,7 +85,7 @@ class PauliSumCollector(collector.Collector):
         self._zeros[job_id] += parities[0]
         self._ones[job_id] += parities[1]
 
-    def estimated_energy(self) -> Union[float, complex]:
+    def estimated_energy(self) -> float | complex:
         """Sums up the sampled expectations, weighted by their coefficients."""
         energy = 0j
         for pauli_string, coef in self._pauli_coef_terms:

cirq/work/sampler.py

@@ -17,7 +17,7 @@
 from __future__ import annotations
 
 import collections
-from typing import Dict, FrozenSet, List, Optional, Sequence, Tuple, TYPE_CHECKING, TypeVar, Union
+from typing import Sequence, TYPE_CHECKING, TypeVar
 
 import duet
 import pandas as pd
@@ -237,8 +237,8 @@ class Sampler(metaclass=value.ABCMetaImplementAnyOneOf):
     async def run_batch_async(
         self,
         programs: Sequence[cirq.AbstractCircuit],
-        params_list: Optional[Sequence[cirq.Sweepable]] = None,
-        repetitions: Union[int, Sequence[int]] = 1,
+        params_list: Sequence[cirq.Sweepable] | None = None,
+        repetitions: int | Sequence[int] = 1,
     ) -> Sequence[Sequence[cirq.Result]]:
         """Runs the supplied circuits asynchronously.
 
@@ -288,9 +288,9 @@ class Sampler(metaclass=value.ABCMetaImplementAnyOneOf):
     def _normalize_batch_args(
         self,
         programs: Sequence[cirq.AbstractCircuit],
-        params_list: Optional[Sequence[cirq.Sweepable]] = None,
-        repetitions: Union[int, Sequence[int]] = 1,
-    ) -> Tuple[Sequence[cirq.Sweepable], Sequence[int]]:
+        params_list: Sequence[cirq.Sweepable] | None = None,
+        repetitions: int | Sequence[int] = 1,
+    ) -> tuple[Sequence[cirq.Sweepable], Sequence[int]]:
         if params_list is None:
             params_list = [None] * len(programs)
         if len(programs) != len(params_list):
@@ -310,7 +310,7 @@ class Sampler(metaclass=value.ABCMetaImplementAnyOneOf):
     def sample_expectation_values(
         self,
         program: cirq.AbstractCircuit,
-        observables: Union[cirq.PauliSumLike, List[cirq.PauliSumLike]],
+        observables: cirq.PauliSumLike | list[cirq.PauliSumLike],
         *,
         num_samples: int,
         params: cirq.Sweepable = None,
@@ -359,17 +359,17 @@ class Sampler(metaclass=value.ABCMetaImplementAnyOneOf):
             )
 
         # Wrap input into a list of pauli sum
-        pauli_sums: List[cirq.PauliSum] = (
+        pauli_sums: list[cirq.PauliSum] = (
             [ops.PauliSum.wrap(o) for o in observables]
-            if isinstance(observables, List)
+            if isinstance(observables, list)
             else [ops.PauliSum.wrap(observables)]
         )
         del observables
 
         # Flatten Pauli Sum into one big list of Pauli String
         # Keep track of which Pauli Sum each one was from.
-        flat_pstrings: List[cirq.PauliString] = []
-        pstring_to_psum_i: Dict[cirq.PauliString, int] = {}
+        flat_pstrings: list[cirq.PauliString] = []
+        pstring_to_psum_i: dict[cirq.PauliString, int] = {}
         for psum_i, pauli_sum in enumerate(pauli_sums):
             for pstring in pauli_sum:
                 flat_pstrings.append(pstring)
@@ -377,10 +377,10 @@ class Sampler(metaclass=value.ABCMetaImplementAnyOneOf):
 
         # Flatten Circuit Sweep into one big list of Params.
         # Keep track of their indices so we can map back.
-        flat_params: List[cirq.ParamMappingType] = [
+        flat_params: list[cirq.ParamMappingType] = [
             pr.param_dict for pr in study.to_resolvers(params)
         ]
-        circuit_param_to_sweep_i: Dict[FrozenSet[Tuple[str, Union[int, Tuple[int, int]]]], int] = {
+        circuit_param_to_sweep_i: dict[frozenset[tuple[str, int | tuple[int, int]]], int] = {
             _hashable_param(param.items()): i for i, param in enumerate(flat_params)
         }
 
@@ -398,7 +398,7 @@ class Sampler(metaclass=value.ABCMetaImplementAnyOneOf):
         # nesting structure, we place the measured values according to the back-mappings we set up
         # above. We also do the sum operation to aggregate multiple PauliString measured values
         # for a given PauliSum.
-        nested_results: List[List[float]] = [[0] * len(pauli_sums) for _ in range(len(flat_params))]
+        nested_results: list[list[float]] = [[0] * len(pauli_sums) for _ in range(len(flat_params))]
         for res in obs_meas_results:
             param_i = circuit_param_to_sweep_i[_hashable_param(res.circuit_params.items())]
             psum_i = pstring_to_psum_i[res.setting.observable]
@@ -409,7 +409,7 @@ class Sampler(metaclass=value.ABCMetaImplementAnyOneOf):
     @staticmethod
     def _get_measurement_shapes(
         circuit: cirq.AbstractCircuit,
-    ) -> Dict[str, Tuple[int, Tuple[int, ...]]]:
+    ) -> dict[str, tuple[int, tuple[int, ...]]]:
         """Gets the shapes of measurements in the given circuit.
 
         Returns:
@@ -422,8 +422,8 @@ class Sampler(metaclass=value.ABCMetaImplementAnyOneOf):
             ValueError: if the qid_shape of different instances of the same measurement
             key disagree.
         """
-        qid_shapes: Dict[str, Tuple[int, ...]] = {}
-        num_instances: Dict[str, int] = collections.Counter()
+        qid_shapes: dict[str, tuple[int, ...]] = {}
+        num_instances: dict[str, int] = collections.Counter()
         for op in circuit.all_operations():
             key = protocols.measurement_key_name(op, default=None)
             if key is not None:

cirq/work/zeros_sampler.py

@@ -15,7 +15,7 @@
 from __future__ import annotations
 
 import abc
-from typing import List, Optional, TYPE_CHECKING
+from typing import TYPE_CHECKING
 
 import numpy as np
 
@@ -28,7 +28,7 @@ if TYPE_CHECKING:
 class ZerosSampler(work.Sampler, metaclass=abc.ABCMeta):
     """A mock sampler for testing. Immediately returns zeroes."""
 
-    def __init__(self, device: Optional[devices.Device] = None):
+    def __init__(self, device: devices.Device | None = None):
         """Construct a sampler that returns 0 for all measurements.
 
         Args:
@@ -39,7 +39,7 @@ class ZerosSampler(work.Sampler, metaclass=abc.ABCMeta):
 
     def run_sweep(
         self, program: cirq.AbstractCircuit, params: study.Sweepable, repetitions: int = 1
-    ) -> List[study.Result]:
+    ) -> list[study.Result]:
         """Samples circuit as if every measurement resulted in zero.
 
         Args:

{cirq_core-1.6.0.dev20250520054601.dist-info → cirq_core-1.6.0.dev20250520181654.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cirq-core
-Version: 1.6.0.dev20250520054601
+Version: 1.6.0.dev20250520181654
 Summary: A framework for creating, editing, and invoking Noisy Intermediate Scale Quantum (NISQ) circuits.
 Home-page: http://github.com/quantumlib/cirq
 Author: The Cirq Developers