cirq-core 1.4.0.dev20240529225110__py3-none-any.whl → 1.5.0__py3-none-any.whl

cirq/devices/noise_model.py

@@ -12,11 +12,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Any, Dict, Iterable, Sequence, TYPE_CHECKING, Union, Callable
+from __future__ import annotations
+
+from typing import Any, Callable, Dict, Iterable, Sequence, TYPE_CHECKING, Union
 
 from cirq import ops, protocols, value
-from cirq._import import LazyLoader
 from cirq._doc import document
+from cirq._import import LazyLoader
 
 moment_module = LazyLoader("moment_module", globals(), "cirq.circuits.moment")
 
@@ -41,7 +43,7 @@ class NoiseModel(metaclass=value.ABCMetaImplementAnyOneOf):
     """
 
     @classmethod
-    def from_noise_model_like(cls, noise: 'cirq.NOISE_MODEL_LIKE') -> 'cirq.NoiseModel':
+    def from_noise_model_like(cls, noise: cirq.NOISE_MODEL_LIKE) -> cirq.NoiseModel:
         """Transforms an object into a noise model if unambiguously possible.
 
         Args:
@@ -76,7 +78,7 @@ class NoiseModel(metaclass=value.ABCMetaImplementAnyOneOf):
             f'or a single qubit gate). Got {noise!r}'
         )
 
-    def is_virtual_moment(self, moment: 'cirq.Moment') -> bool:
+    def is_virtual_moment(self, moment: cirq.Moment) -> bool:
         """Returns true iff the given moment is non-empty and all of its
         operations are virtual.
 
@@ -95,16 +97,16 @@ class NoiseModel(metaclass=value.ABCMetaImplementAnyOneOf):
         return all(ops.VirtualTag() in op.tags for op in moment)
 
     def _noisy_moments_impl_moment(
-        self, moments: Iterable['cirq.Moment'], system_qubits: Sequence['cirq.Qid']
-    ) -> Sequence['cirq.OP_TREE']:
+        self, moments: Iterable[cirq.Moment], system_qubits: Sequence[cirq.Qid]
+    ) -> Sequence[cirq.OP_TREE]:
         result = []
         for moment in moments:
             result.append(self.noisy_moment(moment, system_qubits))
         return result
 
     def _noisy_moments_impl_operation(
-        self, moments: Iterable['cirq.Moment'], system_qubits: Sequence['cirq.Qid']
-    ) -> Sequence['cirq.OP_TREE']:
+        self, moments: Iterable[cirq.Moment], system_qubits: Sequence[cirq.Qid]
+    ) -> Sequence[cirq.OP_TREE]:
         result = []
         for moment in moments:
             result.append([self.noisy_operation(op) for op in moment])
@@ -113,8 +115,8 @@ class NoiseModel(metaclass=value.ABCMetaImplementAnyOneOf):
     @value.alternative(requires='noisy_moment', implementation=_noisy_moments_impl_moment)
     @value.alternative(requires='noisy_operation', implementation=_noisy_moments_impl_operation)
     def noisy_moments(
-        self, moments: Iterable['cirq.Moment'], system_qubits: Sequence['cirq.Qid']
-    ) -> Sequence['cirq.OP_TREE']:
+        self, moments: Iterable[cirq.Moment], system_qubits: Sequence[cirq.Qid]
+    ) -> Sequence[cirq.OP_TREE]:
         """Adds possibly stateful noise to a series of moments.
 
         Args:
@@ -128,20 +130,18 @@ class NoiseModel(metaclass=value.ABCMetaImplementAnyOneOf):
         raise NotImplementedError
 
     def _noisy_moment_impl_moments(
-        self, moment: 'cirq.Moment', system_qubits: Sequence['cirq.Qid']
-    ) -> 'cirq.OP_TREE':
+        self, moment: cirq.Moment, system_qubits: Sequence[cirq.Qid]
+    ) -> cirq.OP_TREE:
         return self.noisy_moments([moment], system_qubits)
 
     def _noisy_moment_impl_operation(
-        self, moment: 'cirq.Moment', system_qubits: Sequence['cirq.Qid']
-    ) -> 'cirq.OP_TREE':
+        self, moment: cirq.Moment, system_qubits: Sequence[cirq.Qid]
+    ) -> cirq.OP_TREE:
         return [self.noisy_operation(op) for op in moment]
 
     @value.alternative(requires='noisy_moments', implementation=_noisy_moment_impl_moments)
     @value.alternative(requires='noisy_operation', implementation=_noisy_moment_impl_operation)
-    def noisy_moment(
-        self, moment: 'cirq.Moment', system_qubits: Sequence['cirq.Qid']
-    ) -> 'cirq.OP_TREE':
+    def noisy_moment(self, moment: cirq.Moment, system_qubits: Sequence[cirq.Qid]) -> cirq.OP_TREE:
         """Adds noise to the operations from a moment.
 
         Args:
@@ -153,15 +153,15 @@ class NoiseModel(metaclass=value.ABCMetaImplementAnyOneOf):
         """
         raise NotImplementedError
 
-    def _noisy_operation_impl_moments(self, operation: 'cirq.Operation') -> 'cirq.OP_TREE':
+    def _noisy_operation_impl_moments(self, operation: cirq.Operation) -> cirq.OP_TREE:
         return self.noisy_moments([moment_module.Moment([operation])], operation.qubits)
 
-    def _noisy_operation_impl_moment(self, operation: 'cirq.Operation') -> 'cirq.OP_TREE':
+    def _noisy_operation_impl_moment(self, operation: cirq.Operation) -> cirq.OP_TREE:
         return self.noisy_moment(moment_module.Moment([operation]), operation.qubits)
 
     @value.alternative(requires='noisy_moments', implementation=_noisy_operation_impl_moments)
     @value.alternative(requires='noisy_moment', implementation=_noisy_operation_impl_moment)
-    def noisy_operation(self, operation: 'cirq.Operation') -> 'cirq.OP_TREE':
+    def noisy_operation(self, operation: cirq.Operation) -> cirq.OP_TREE:
         """Adds noise to an individual operation.
 
         Args:
@@ -178,15 +178,13 @@ class NoiseModel(metaclass=value.ABCMetaImplementAnyOneOf):
 class _NoNoiseModel(NoiseModel):
     """A default noise model that adds no noise."""
 
-    def noisy_moments(self, moments: Iterable['cirq.Moment'], system_qubits: Sequence['cirq.Qid']):
+    def noisy_moments(self, moments: Iterable[cirq.Moment], system_qubits: Sequence[cirq.Qid]):
         return list(moments)
 
-    def noisy_moment(
-        self, moment: 'cirq.Moment', system_qubits: Sequence['cirq.Qid']
-    ) -> 'cirq.Moment':
+    def noisy_moment(self, moment: cirq.Moment, system_qubits: Sequence[cirq.Qid]) -> cirq.Moment:
         return moment
 
-    def noisy_operation(self, operation: 'cirq.Operation') -> 'cirq.Operation':
+    def noisy_operation(self, operation: cirq.Operation) -> cirq.Operation:
         return operation
 
     def _value_equality_values_(self) -> Any:
@@ -216,7 +214,7 @@ class ConstantQubitNoiseModel(NoiseModel):
     operation is given as "the noise to use" for a `NOISE_MODEL_LIKE` parameter.
     """
 
-    def __init__(self, qubit_noise_gate: 'cirq.Gate', prepend: bool = False):
+    def __init__(self, qubit_noise_gate: cirq.Gate, prepend: bool = False):
         """Noise model which applies a specific gate as noise to all gates.
 
         Args:
@@ -237,7 +235,7 @@ class ConstantQubitNoiseModel(NoiseModel):
     def __repr__(self) -> str:
         return f'cirq.ConstantQubitNoiseModel({self.qubit_noise_gate!r})'
 
-    def noisy_moment(self, moment: 'cirq.Moment', system_qubits: Sequence['cirq.Qid']):
+    def noisy_moment(self, moment: cirq.Moment, system_qubits: Sequence[cirq.Qid]):
         # Noise should not be appended to previously-added noise.
         if self.is_virtual_moment(moment):
             return moment
@@ -260,7 +258,7 @@ class ConstantQubitNoiseModel(NoiseModel):
 
 
 class GateSubstitutionNoiseModel(NoiseModel):
-    def __init__(self, substitution_func: Callable[['cirq.Operation'], 'cirq.Operation']):
+    def __init__(self, substitution_func: Callable[[cirq.Operation], cirq.Operation]):
         """Noise model which replaces operations using a substitution function.
 
         Args:
@@ -268,13 +266,11 @@ class GateSubstitutionNoiseModel(NoiseModel):
         """
         self.substitution_func = substitution_func
 
-    def noisy_moment(
-        self, moment: 'cirq.Moment', system_qubits: Sequence['cirq.Qid']
-    ) -> 'cirq.OP_TREE':
+    def noisy_moment(self, moment: cirq.Moment, system_qubits: Sequence[cirq.Qid]) -> cirq.OP_TREE:
         return moment_module.Moment([self.substitution_func(op) for op in moment.operations])
 
 
-NO_NOISE: 'cirq.NoiseModel' = _NoNoiseModel()
+NO_NOISE: cirq.NoiseModel = _NoNoiseModel()
 document(
     NO_NOISE,
     """The trivial noise model with no effects.
@@ -298,7 +294,7 @@ document(
 )
 
 
-def validate_all_measurements(moment: 'cirq.Moment') -> bool:
+def validate_all_measurements(moment: cirq.Moment) -> bool:
     """Ensures that the moment is homogenous and returns whether all ops are measurement gates.
 
     Args:

cirq/devices/noise_properties.py

@@ -20,9 +20,9 @@ noise models to produce a single noise model which replicates device noise.
 """
 
 import abc
-from typing import Iterable, Sequence, TYPE_CHECKING, List
+from typing import Iterable, List, Sequence, TYPE_CHECKING
 
-from cirq import _import, ops, protocols, devices
+from cirq import _import, devices, ops, protocols
 from cirq.devices.noise_utils import PHYSICAL_GATE_TAG
 
 circuits = _import.LazyLoader("circuits", globals(), "cirq.circuits.circuit")

cirq/devices/noise_properties_test.py

@@ -13,10 +13,10 @@
 # limitations under the License.
 
 from typing import List, Tuple
-import cirq
 
+import cirq
 from cirq.devices.insertion_noise_model import InsertionNoiseModel
-from cirq.devices.noise_properties import NoiseProperties, NoiseModelFromNoiseProperties
+from cirq.devices.noise_properties import NoiseModelFromNoiseProperties, NoiseProperties
 from cirq.devices.noise_utils import OpIdentifier, PHYSICAL_GATE_TAG
 
 

cirq/devices/noise_utils.py

@@ -12,10 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import TYPE_CHECKING, Any, Dict, Tuple, Type, Union
+from typing import Any, Dict, Tuple, Type, TYPE_CHECKING, Union
 
-from cirq import ops, protocols, value, qis
-from cirq._compat import proper_repr, deprecated
+from cirq import ops, protocols, qis, value
+from cirq._compat import deprecated, proper_repr
 
 if TYPE_CHECKING:
     import cirq

cirq/devices/superconducting_qubits_noise_properties.py

@@ -18,9 +18,9 @@
 import abc
 from dataclasses import dataclass, field
 from functools import cached_property
-from typing import Dict, TYPE_CHECKING, List, Set, Type
+from typing import Dict, List, Set, Type, TYPE_CHECKING
 
-from cirq import ops, devices, qis
+from cirq import devices, ops, qis
 from cirq.devices import noise_utils
 
 if TYPE_CHECKING:

cirq/devices/superconducting_qubits_noise_properties_test.py

@@ -13,16 +13,16 @@
 # limitations under the License.
 
 from typing import Dict, List, Set, Tuple
+
 import numpy as np
-import cirq
 import pytest
 
+import cirq
 from cirq.devices.noise_properties import NoiseModelFromNoiseProperties
+from cirq.devices.noise_utils import OpIdentifier, PHYSICAL_GATE_TAG
 from cirq.devices.superconducting_qubits_noise_properties import (
     SuperconductingQubitsNoiseProperties,
 )
-from cirq.devices.noise_utils import OpIdentifier, PHYSICAL_GATE_TAG
-
 
 DEFAULT_GATE_NS: Dict[type, float] = {
     cirq.ZPowGate: 25.0,

cirq/devices/thermal_noise_model.py

@@ -14,7 +14,8 @@
 
 import dataclasses
 import functools
-from typing import TYPE_CHECKING, Dict, List, Optional, Sequence, Set, Tuple, Union
+from typing import Dict, List, Optional, Sequence, Set, Tuple, TYPE_CHECKING, Union
+
 import numpy as np
 import sympy
 

cirq/devices/unconstrained_device.py

@@ -14,7 +14,7 @@
 
 from typing import Any, Dict, TYPE_CHECKING
 
-from cirq import value, protocols
+from cirq import protocols, value
 from cirq._doc import document
 from cirq.devices import device
 

cirq/devices/unconstrained_device_test.py

@@ -23,3 +23,9 @@ def test_infinitely_fast():
     assert cirq.UNCONSTRAINED_DEVICE.duration_of(cirq.X(cirq.NamedQubit('a'))) == cirq.Duration(
         picos=0
     )
+
+
+def test_any_qubit_works():
+    moment = cirq.Moment([cirq.X(cirq.LineQubit(987654321))])
+    cirq.UNCONSTRAINED_DEVICE.validate_moment(moment)
+    cirq.UNCONSTRAINED_DEVICE.validate_circuit(cirq.Circuit(moment))

cirq/experiments/__init__.py

@@ -14,60 +14,77 @@
 """Experiments and tools for characterizing quantum operations."""
 
 from cirq.experiments.qubit_characterizations import (
-    RandomizedBenchMarkResult,
-    single_qubit_randomized_benchmarking,
-    single_qubit_state_tomography,
-    TomographyResult,
-    two_qubit_randomized_benchmarking,
-    two_qubit_state_tomography,
-    parallel_single_qubit_randomized_benchmarking,
+    RandomizedBenchMarkResult as RandomizedBenchMarkResult,
+    single_qubit_randomized_benchmarking as single_qubit_randomized_benchmarking,
+    single_qubit_state_tomography as single_qubit_state_tomography,
+    TomographyResult as TomographyResult,
+    two_qubit_randomized_benchmarking as two_qubit_randomized_benchmarking,
+    two_qubit_state_tomography as two_qubit_state_tomography,
+    parallel_single_qubit_randomized_benchmarking as parallel_single_qubit_randomized_benchmarking,
 )
 
 from cirq.experiments.fidelity_estimation import (
-    hog_score_xeb_fidelity_from_probabilities,
-    linear_xeb_fidelity_from_probabilities,
-    linear_xeb_fidelity,
-    log_xeb_fidelity,
-    log_xeb_fidelity_from_probabilities,
-    xeb_fidelity,
+    hog_score_xeb_fidelity_from_probabilities as hog_score_xeb_fidelity_from_probabilities,
+    linear_xeb_fidelity_from_probabilities as linear_xeb_fidelity_from_probabilities,
+    linear_xeb_fidelity as linear_xeb_fidelity,
+    log_xeb_fidelity as log_xeb_fidelity,
+    log_xeb_fidelity_from_probabilities as log_xeb_fidelity_from_probabilities,
+    xeb_fidelity as xeb_fidelity,
 )
 
-from cirq.experiments.purity_estimation import purity_from_probabilities
+from cirq.experiments.purity_estimation import (
+    purity_from_probabilities as purity_from_probabilities,
+)
 
 from cirq.experiments.random_quantum_circuit_generation import (
-    GRID_ALIGNED_PATTERN,
-    GRID_STAGGERED_PATTERN,
-    HALF_GRID_STAGGERED_PATTERN,
-    GridInteractionLayer,
-    random_rotations_between_grid_interaction_layers_circuit,
+    # pylint: disable=line-too-long
+    GRID_ALIGNED_PATTERN as GRID_ALIGNED_PATTERN,
+    GRID_STAGGERED_PATTERN as GRID_STAGGERED_PATTERN,
+    HALF_GRID_STAGGERED_PATTERN as HALF_GRID_STAGGERED_PATTERN,
+    GridInteractionLayer as GridInteractionLayer,
+    random_rotations_between_grid_interaction_layers_circuit as random_rotations_between_grid_interaction_layers_circuit,
 )
 
 from cirq.experiments.readout_confusion_matrix import (
-    TensoredConfusionMatrices,
-    measure_confusion_matrix,
+    TensoredConfusionMatrices as TensoredConfusionMatrices,
+    measure_confusion_matrix as measure_confusion_matrix,
 )
 
 from cirq.experiments.n_qubit_tomography import (
-    get_state_tomography_data,
-    state_tomography,
-    StateTomographyExperiment,
+    get_state_tomography_data as get_state_tomography_data,
+    state_tomography as state_tomography,
+    StateTomographyExperiment as StateTomographyExperiment,
 )
 
 from cirq.experiments.single_qubit_readout_calibration import (
-    estimate_parallel_single_qubit_readout_errors,
-    estimate_single_qubit_readout_errors,
-    SingleQubitReadoutCalibrationResult,
+    estimate_parallel_single_qubit_readout_errors as estimate_parallel_single_qubit_readout_errors,
+    estimate_single_qubit_readout_errors as estimate_single_qubit_readout_errors,
+    SingleQubitReadoutCalibrationResult as SingleQubitReadoutCalibrationResult,
 )
 
-from cirq.experiments.t1_decay_experiment import t1_decay, T1DecayResult
+from cirq.experiments.t1_decay_experiment import (
+    t1_decay as t1_decay,
+    T1DecayResult as T1DecayResult,
+)
 
-from cirq.experiments.t2_decay_experiment import t2_decay, T2DecayResult
+from cirq.experiments.t2_decay_experiment import (
+    t2_decay as t2_decay,
+    T2DecayResult as T2DecayResult,
+)
 
-from cirq.experiments.xeb_fitting import XEBPhasedFSimCharacterizationOptions
+from cirq.experiments.xeb_fitting import (
+    XEBPhasedFSimCharacterizationOptions as XEBPhasedFSimCharacterizationOptions,
+)
 
 from cirq.experiments.two_qubit_xeb import (
-    InferredXEBResult,
-    TwoQubitXEBResult,
-    parallel_two_qubit_xeb,
-    run_rb_and_xeb,
+    InferredXEBResult as InferredXEBResult,
+    TwoQubitXEBResult as TwoQubitXEBResult,
+    parallel_two_qubit_xeb as parallel_two_qubit_xeb,
+    run_rb_and_xeb as run_rb_and_xeb,
+)
+
+
+from cirq.experiments.z_phase_calibration import (
+    z_phase_calibration_workflow as z_phase_calibration_workflow,
+    calibrate_z_phases as calibrate_z_phases,
 )

cirq/experiments/qubit_characterizations.py

@@ -13,34 +13,33 @@
 # limitations under the License.
 
 import dataclasses
-import itertools
 import functools
-
+import itertools
 from typing import (
     Any,
     cast,
+    Dict,
     Iterator,
     List,
+    Mapping,
     Optional,
     Sequence,
     Tuple,
     TYPE_CHECKING,
-    Mapping,
-    Dict,
 )
-import numpy as np
-from scipy.optimize import curve_fit
 
+import numpy as np
 from matplotlib import pyplot as plt
-import cirq.vis.heatmap as cirq_heatmap
-import cirq.vis.histogram as cirq_histogram
 
 # this is for older systems with matplotlib <3.2 otherwise 3d projections fail
 from mpl_toolkits import mplot3d
+from scipy.optimize import curve_fit
+
+import cirq.vis.heatmap as cirq_heatmap
+import cirq.vis.histogram as cirq_histogram
 from cirq import circuits, ops, protocols
 from cirq.devices import grid_qubit
 
-
 if TYPE_CHECKING:
     import cirq
 
@@ -105,9 +104,8 @@ class RandomizedBenchMarkResult:
             The plt.Axes containing the plot.
         """
         show_plot = not ax
-        if not ax:
+        if ax is None:
             fig, ax = plt.subplots(1, 1, figsize=(8, 8))  # pragma: no cover
-            ax = cast(plt.Axes, ax)  # pragma: no cover
         ax.set_ylim((0.0, 1.0))  # pragma: no cover
         ax.plot(self._num_cfds_seq, self._gnd_state_probs, 'ro', label='data', **plot_kwargs)
         x = np.linspace(self._num_cfds_seq[0], self._num_cfds_seq[-1], 100)
@@ -131,7 +129,7 @@ class RandomizedBenchMarkResult:
 
         $$r_p = (1 - 1/d^2) * (1 - p),$$
 
-        where $d = 2^N_Q$ is the Hilbert space dimension and $N_Q$ is the number of qubits.
+        where $d = 2^{N_Q}$ is the Hilbert space dimension and $N_Q$ is the number of qubits.
         """
         opt_params, _ = self._fit_exponential()
         p = opt_params[2]
@@ -287,7 +285,9 @@ class TomographyResult:
         """
         return self._density_matrix
 
-    def plot(self, axes: Optional[List[plt.Axes]] = None, **plot_kwargs: Any) -> List[plt.Axes]:
+    def plot(
+        self, axes: Optional[List[plt.Axes]] = None, **plot_kwargs: Any
+    ) -> List[plt.Axes]:  # pragma: no cover
         """Plots the real and imaginary parts of the density matrix as two 3D bar plots.
 
         Args:
@@ -304,7 +304,9 @@ class TomographyResult:
         """
         show_plot = axes is None
         if axes is None:
-            fig, axes = plt.subplots(1, 2, figsize=(12.0, 5.0), subplot_kw={'projection': '3d'})
+            fig, axes_v = plt.subplots(1, 2, figsize=(12.0, 5.0), subplot_kw={'projection': '3d'})
+            axes_v = cast(np.ndarray, axes_v)
+            axes = list(axes_v)
         elif len(axes) != 2:
             raise ValueError('A TomographyResult needs 2 axes to plot.')
         mat = self._density_matrix
@@ -780,7 +782,7 @@ def _matrix_bar_plot(
     title: Optional[str] = None,
     ylim: Tuple[int, int] = (-1, 1),
     **bar3d_kwargs: Any,
-) -> None:
+) -> None:  # pragma: no cover
     num_rows, num_cols = mat.shape
     indices = np.meshgrid(range(num_cols), range(num_rows))
     x_indices = np.array(indices[1]).flatten()

cirq/experiments/qubit_characterizations_test.py

@@ -12,21 +12,19 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import matplotlib.pyplot as plt
 import numpy as np
 import pytest
 
-import matplotlib.pyplot as plt
-
 import cirq
 import cirq.experiments.qubit_characterizations as ceqc
-from cirq import GridQubit
-from cirq import circuits, ops, sim
+from cirq import circuits, GridQubit, ops, sim
 from cirq.experiments import (
+    parallel_single_qubit_randomized_benchmarking,
     single_qubit_randomized_benchmarking,
-    two_qubit_randomized_benchmarking,
     single_qubit_state_tomography,
+    two_qubit_randomized_benchmarking,
     two_qubit_state_tomography,
-    parallel_single_qubit_randomized_benchmarking,
 )
 
 

cirq/experiments/random_quantum_circuit_generation.py

@@ -18,17 +18,17 @@ import itertools
 from typing import (
     Any,
     Callable,
+    cast,
     Container,
     Dict,
     Iterable,
+    Iterator,
     List,
+    Optional,
     Sequence,
-    TYPE_CHECKING,
     Tuple,
+    TYPE_CHECKING,
     Union,
-    Optional,
-    cast,
-    Iterator,
 )
 
 import networkx as nx
@@ -249,6 +249,7 @@ def generate_library_of_2q_circuits(
     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']:
     """Generate a library of two-qubit Circuits.
 
@@ -265,6 +266,7 @@ def generate_library_of_2q_circuits(
         q0: The first qubit to use when constructing the circuits.
         q1: The second qubit to use when constructing the circuits
         random_state: A random state or seed used to deterministically sample the random circuits.
+        tags: Tags to add to the two qubit operations.
     """
     rs = value.parse_random_state(random_state)
     exponents = np.linspace(0, 7 / 4, 8)
@@ -277,7 +279,7 @@ def generate_library_of_2q_circuits(
             q0,
             q1,
             depth=max_cycle_depth,
-            two_qubit_op_factory=lambda a, b, _: two_qubit_gate(a, b),
+            two_qubit_op_factory=lambda a, b, _: two_qubit_gate(a, b).with_tags(*tags),
             single_qubit_gates=single_qubit_gates,
             seed=rs,
         )
@@ -539,9 +541,8 @@ def get_grid_interaction_layer_circuit(
     moments = []
     for layer in pattern:
         pairs = sorted(_get_active_pairs(device_graph, layer))
-        if len(pairs) == 0:
-            continue
-        moments += [circuits.Moment(two_qubit_gate.on(*pair) for pair in pairs)]
+        if pairs:
+            moments += [circuits.Moment(two_qubit_gate.on(*pair) for pair in pairs)]
     return circuits.Circuit(moments)
 
 
@@ -691,7 +692,7 @@ def _two_qubit_layer(
     ],
     layer: GridInteractionLayer,
     prng: 'np.random.RandomState',
-) -> 'cirq.OP_TREE':
+) -> 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

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 import itertools
-from typing import Callable, Dict, Iterable, List, Optional, Sequence, Set, Tuple, cast
+from typing import Callable, cast, Dict, Iterable, List, Optional, Sequence, Set, Tuple
 
 import networkx as nx
 import numpy as np
@@ -24,12 +24,12 @@ from cirq.experiments import (
     random_rotations_between_grid_interaction_layers_circuit,
 )
 from cirq.experiments.random_quantum_circuit_generation import (
-    random_rotations_between_two_qubit_circuit,
     generate_library_of_2q_circuits,
+    get_grid_interaction_layer_circuit,
     get_random_combinations_for_device,
-    get_random_combinations_for_pairs,
     get_random_combinations_for_layer_circuit,
-    get_grid_interaction_layer_circuit,
+    get_random_combinations_for_pairs,
+    random_rotations_between_two_qubit_circuit,
 )
 
 SINGLE_QUBIT_LAYER = Dict[cirq.GridQubit, Optional[cirq.Gate]]
@@ -457,3 +457,20 @@ def _coupled_qubit_pairs(
         add_pair(cirq.GridQubit(qubit.row + 1, qubit.col))
 
     return pairs
+
+
+def test_generate_library_of_2q_circuits_with_tags():
+    circuits = generate_library_of_2q_circuits(
+        n_library_circuits=5,
+        two_qubit_gate=cirq.FSimGate(3, 4),
+        max_cycle_depth=13,
+        random_state=9,
+        tags=('test_tag',),
+    )
+    assert len(circuits) == 5
+    for circuit in circuits:
+        for op in circuit.all_operations():
+            if cirq.num_qubits(op) == 1:
+                continue
+            assert op.tags == ('test_tag',)
+            assert op.gate == cirq.FSimGate(3, 4)