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

cirq/experiments/random_quantum_circuit_generation.py

@@ -13,6 +13,8 @@
 # limitations under the License.
 """Code for generating random quantum circuits."""
 
+from __future__ import annotations
+
 import dataclasses
 import itertools
 from typing import (
@@ -179,20 +181,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 +245,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
@@ -316,7 +318,7 @@ def _get_random_combinations(
     n_combinations: int,
     *,
     pair_gen: Iterator[Tuple[List[QidPairT], Any]],
-    random_state: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None,
+    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,7 +368,7 @@ 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,
+    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.
@@ -420,7 +422,7 @@ 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,
+    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,7 +462,7 @@ 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.
@@ -477,8 +479,8 @@ def _pairs_from_moment(moment: 'cirq.Moment') -> List[QidPairT]:
 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,
+    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 +525,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 +549,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 +621,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 +639,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,10 +660,10 @@ 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())
 
 
@@ -669,9 +671,7 @@ _SingleQubitLayerFactory = Union[_FixedSingleQubitLayerFactory, _RandomSingleQub
 
 
 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.
 
@@ -688,11 +688,11 @@ def _single_qubit_gates_arg_to_factory(
 def _two_qubit_layer(
     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,6 +11,9 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+
+from __future__ import annotations
+
 import itertools
 from typing import Callable, cast, Dict, Iterable, List, Optional, Sequence, Set, Tuple
 
@@ -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,
@@ -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,6 +14,8 @@
 
 """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
 
@@ -60,7 +62,7 @@ class TensoredConfusionMatrices:
     def __init__(
         self,
         confusion_matrices: Union[np.ndarray, Sequence[np.ndarray]],
-        measure_qubits: Union[Sequence['cirq.Qid'], Sequence[Sequence['cirq.Qid']]],
+        measure_qubits: Union[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.
@@ -160,21 +162,21 @@ class TensoredConfusionMatrices:
         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:
+    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)])
@@ -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: Optional[Sequence[cirq.Qid]] = 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: Optional[Sequence[cirq.Qid]] = 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: Optional[Sequence[cirq.Qid]] = 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.
 
@@ -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: Union[Sequence[cirq.Qid], Sequence[Sequence[cirq.Qid]]],
     repetitions: int = 1000,
 ) -> TensoredConfusionMatrices:
     """Prepares `TensoredConfusionMatrices` for the n qubits in the input.

cirq/experiments/single_qubit_readout_calibration.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.
+
 """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
@@ -43,8 +47,8 @@ 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
 
@@ -197,7 +201,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,9 +233,9 @@ 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,

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:

cirq/experiments/t1_decay_experiment.py

@@ -12,6 +12,8 @@
 # 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
 
@@ -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,

cirq/experiments/t2_decay_experiment.py

@@ -11,6 +11,9 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+
+from __future__ import annotations
+
 import enum
 from typing import Any, List, Optional, TYPE_CHECKING, Union
 
@@ -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']]:
+) -> Union[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: