cirq-core 1.5.0.dev20250118135200__py3-none-any.whl → 1.5.0.dev20250121182620__py3-none-any.whl

cirq/_version.py

@@ -28,4 +28,4 @@ if sys.version_info < (3, 10, 0):  # pragma: no cover
         'of cirq (e.g. "python -m pip install cirq==1.1.*")'
     )
 
-__version__ = "1.5.0.dev20250118135200"
+__version__ = "1.5.0.dev20250121182620"

cirq/_version_test.py

@@ -3,4 +3,4 @@ import cirq
 
 
 def test_version():
-    assert cirq.__version__ == "1.5.0.dev20250118135200"
+    assert cirq.__version__ == "1.5.0.dev20250121182620"

cirq/json_resolver_cache.py

@@ -49,7 +49,6 @@ def _class_resolver_dictionary() -> Dict[str, ObjectFactory]:
     from cirq.devices.noise_model import _NoNoiseModel
     from cirq.devices import InsertionNoiseModel
     from cirq.experiments import GridInteractionLayer
-    from cirq.experiments.grid_parallel_two_qubit_xeb import GridParallelXEBMetadata
 
     def _boolean_hamiltonian_gate_op(qubit_map, boolean_strs, theta):
         return cirq.BooleanHamiltonianGate(
@@ -142,7 +141,6 @@ def _class_resolver_dictionary() -> Dict[str, ObjectFactory]:
         'GlobalPhaseGate': cirq.GlobalPhaseGate,
         'GridDeviceMetadata': cirq.GridDeviceMetadata,
         'GridInteractionLayer': GridInteractionLayer,
-        'GridParallelXEBMetadata': GridParallelXEBMetadata,
         'GridQid': cirq.GridQid,
         'GridQubit': cirq.GridQubit,
         'HPowGate': cirq.HPowGate,

cirq/transformers/gauge_compiling/__init__.py

@@ -18,6 +18,7 @@ from cirq.transformers.gauge_compiling.gauge_compiling import (
     Gauge as Gauge,
     GaugeSelector as GaugeSelector,
     GaugeTransformer as GaugeTransformer,
+    TwoQubitGateSymbolizer as TwoQubitGateSymbolizer,
 )
 
 from cirq.transformers.gauge_compiling.sqrt_cz_gauge import (

cirq/transformers/gauge_compiling/cz_gauge.py

@@ -24,134 +24,22 @@ from cirq import ops
 
 CZGaugeSelector = GaugeSelector(
     gauges=[
-        ConstantGauge(
-            two_qubit_gate=CZ,
-            pre_q0=ops.I,
-            pre_q1=ops.I,
-            post_q0=ops.I,
-            post_q1=ops.I,
-            support_sweep=True,
-        ),
-        ConstantGauge(
-            two_qubit_gate=CZ,
-            pre_q0=ops.I,
-            pre_q1=ops.X,
-            post_q0=ops.Z,
-            post_q1=ops.X,
-            support_sweep=True,
-        ),
-        ConstantGauge(
-            two_qubit_gate=CZ,
-            pre_q0=ops.I,
-            pre_q1=ops.Y,
-            post_q0=ops.Z,
-            post_q1=ops.Y,
-            support_sweep=True,
-        ),
-        ConstantGauge(
-            two_qubit_gate=CZ,
-            pre_q0=ops.I,
-            pre_q1=ops.Z,
-            post_q0=ops.I,
-            post_q1=ops.Z,
-            support_sweep=True,
-        ),
-        ConstantGauge(
-            two_qubit_gate=CZ,
-            pre_q0=ops.X,
-            pre_q1=ops.I,
-            post_q0=ops.X,
-            post_q1=ops.Z,
-            support_sweep=True,
-        ),
-        ConstantGauge(
-            two_qubit_gate=CZ,
-            pre_q0=ops.X,
-            pre_q1=ops.X,
-            post_q0=ops.Y,
-            post_q1=ops.Y,
-            support_sweep=True,
-        ),
-        ConstantGauge(
-            two_qubit_gate=CZ,
-            pre_q0=ops.X,
-            pre_q1=ops.Y,
-            post_q0=ops.Y,
-            post_q1=ops.X,
-            support_sweep=True,
-        ),
-        ConstantGauge(
-            two_qubit_gate=CZ,
-            pre_q0=ops.X,
-            pre_q1=ops.Z,
-            post_q0=ops.X,
-            post_q1=ops.I,
-            support_sweep=True,
-        ),
-        ConstantGauge(
-            two_qubit_gate=CZ,
-            pre_q0=ops.Y,
-            pre_q1=ops.I,
-            post_q0=ops.Y,
-            post_q1=ops.Z,
-            support_sweep=True,
-        ),
-        ConstantGauge(
-            two_qubit_gate=CZ,
-            pre_q0=ops.Y,
-            pre_q1=ops.X,
-            post_q0=ops.X,
-            post_q1=ops.Y,
-            support_sweep=True,
-        ),
-        ConstantGauge(
-            two_qubit_gate=CZ,
-            pre_q0=ops.Y,
-            pre_q1=ops.Y,
-            post_q0=ops.X,
-            post_q1=ops.X,
-            support_sweep=True,
-        ),
-        ConstantGauge(
-            two_qubit_gate=CZ,
-            pre_q0=ops.Y,
-            pre_q1=ops.Z,
-            post_q0=ops.Y,
-            post_q1=ops.I,
-            support_sweep=True,
-        ),
-        ConstantGauge(
-            two_qubit_gate=CZ,
-            pre_q0=ops.Z,
-            pre_q1=ops.I,
-            post_q0=ops.Z,
-            post_q1=ops.I,
-            support_sweep=True,
-        ),
-        ConstantGauge(
-            two_qubit_gate=CZ,
-            pre_q0=ops.Z,
-            pre_q1=ops.X,
-            post_q0=ops.I,
-            post_q1=ops.X,
-            support_sweep=True,
-        ),
-        ConstantGauge(
-            two_qubit_gate=CZ,
-            pre_q0=ops.Z,
-            pre_q1=ops.Y,
-            post_q0=ops.I,
-            post_q1=ops.Y,
-            support_sweep=True,
-        ),
-        ConstantGauge(
-            two_qubit_gate=CZ,
-            pre_q0=ops.Z,
-            pre_q1=ops.Z,
-            post_q0=ops.Z,
-            post_q1=ops.Z,
-            support_sweep=True,
-        ),
+        ConstantGauge(two_qubit_gate=CZ, pre_q0=ops.I, pre_q1=ops.I, post_q0=ops.I, post_q1=ops.I),
+        ConstantGauge(two_qubit_gate=CZ, pre_q0=ops.I, pre_q1=ops.X, post_q0=ops.Z, post_q1=ops.X),
+        ConstantGauge(two_qubit_gate=CZ, pre_q0=ops.I, pre_q1=ops.Y, post_q0=ops.Z, post_q1=ops.Y),
+        ConstantGauge(two_qubit_gate=CZ, pre_q0=ops.I, pre_q1=ops.Z, post_q0=ops.I, post_q1=ops.Z),
+        ConstantGauge(two_qubit_gate=CZ, pre_q0=ops.X, pre_q1=ops.I, post_q0=ops.X, post_q1=ops.Z),
+        ConstantGauge(two_qubit_gate=CZ, pre_q0=ops.X, pre_q1=ops.X, post_q0=ops.Y, post_q1=ops.Y),
+        ConstantGauge(two_qubit_gate=CZ, pre_q0=ops.X, pre_q1=ops.Y, post_q0=ops.Y, post_q1=ops.X),
+        ConstantGauge(two_qubit_gate=CZ, pre_q0=ops.X, pre_q1=ops.Z, post_q0=ops.X, post_q1=ops.I),
+        ConstantGauge(two_qubit_gate=CZ, pre_q0=ops.Y, pre_q1=ops.I, post_q0=ops.Y, post_q1=ops.Z),
+        ConstantGauge(two_qubit_gate=CZ, pre_q0=ops.Y, pre_q1=ops.X, post_q0=ops.X, post_q1=ops.Y),
+        ConstantGauge(two_qubit_gate=CZ, pre_q0=ops.Y, pre_q1=ops.Y, post_q0=ops.X, post_q1=ops.X),
+        ConstantGauge(two_qubit_gate=CZ, pre_q0=ops.Y, pre_q1=ops.Z, post_q0=ops.Y, post_q1=ops.I),
+        ConstantGauge(two_qubit_gate=CZ, pre_q0=ops.Z, pre_q1=ops.I, post_q0=ops.Z, post_q1=ops.I),
+        ConstantGauge(two_qubit_gate=CZ, pre_q0=ops.Z, pre_q1=ops.X, post_q0=ops.I, post_q1=ops.X),
+        ConstantGauge(two_qubit_gate=CZ, pre_q0=ops.Z, pre_q1=ops.Y, post_q0=ops.I, post_q1=ops.Y),
+        ConstantGauge(two_qubit_gate=CZ, pre_q0=ops.Z, pre_q1=ops.Z, post_q0=ops.Z, post_q1=ops.Z),
     ]
 )
 

cirq/transformers/gauge_compiling/gauge_compiling.py

@@ -15,8 +15,8 @@
 """Creates the abstraction for gauge compiling as a cirq transformer."""
 
 from typing import Callable, Dict, Tuple, Optional, Sequence, Union, List
-from itertools import count
 from dataclasses import dataclass
+from numbers import Real
 import abc
 import itertools
 import functools
@@ -79,7 +79,6 @@ class ConstantGauge(Gauge):
         default=(), converter=lambda g: (g,) if isinstance(g, ops.Gate) else tuple(g)
     )
     swap_qubits: bool = False
-    support_sweep: bool = False
 
     def sample(self, gate: ops.Gate, prng: np.random.Generator) -> "ConstantGauge":
         return self
@@ -118,7 +117,6 @@ class SameGateGauge(Gauge):
         default=(), converter=lambda g: (g,) if isinstance(g, ops.Gate) else tuple(g)
     )
     swap_qubits: bool = False
-    support_sweep: bool = False
 
     def sample(self, gate: ops.Gate, prng: np.random.Generator) -> ConstantGauge:
         return ConstantGauge(
@@ -128,10 +126,46 @@ class SameGateGauge(Gauge):
             post_q0=self.post_q0,
             post_q1=self.post_q1,
             swap_qubits=self.swap_qubits,
-            support_sweep=self.support_sweep,
         )
 
 
+@frozen
+class TwoQubitGateSymbolizer:
+    """Parameterizes two qubit gates with symbols.
+
+    Attributes:
+        symbolizer: A callable that takes a two-qubit gate and a sequence of symbols,
+            and returns a tuple containing the parameterized gate and a dictionary
+            mapping symbol names to their values.
+        n_symbols: The number of symbols to use for parameterization.
+    """
+
+    symbolizer_fn: Callable[[ops.Gate, Sequence[sympy.Symbol]], Tuple[ops.Gate, Dict[str, Real]]]
+    n_symbols: int
+
+    def __call__(
+        self, two_qubit_gate: ops.Gate, symbols: Sequence[sympy.Symbol]
+    ) -> Tuple[ops.Gate, Dict[str, Real]]:
+        """Symbolizes a two qubit gate to a parameterized gate.
+
+        Args:
+            two_qubit_gate: The 2 qubit gate to be symbolized.
+            symbols: A sequence of sympy symbols to use for parameterization.
+
+        Returns:
+            A tuple containing the parameterized gate and a dictionary mapping
+            symbol names to their values.
+
+        Raises:
+            ValueError: If the provided symbols do not match the expected number.
+        """
+        if len(symbols) != self.n_symbols:
+            raise ValueError(
+                f"Expect {self.n_symbols} symbols, but got {len(symbols)} symbols in {symbols}"
+            )
+        return self.symbolizer_fn(two_qubit_gate, symbols)
+
+
 def _select(choices: Sequence[Gauge], probabilites: np.ndarray, prng: np.random.Generator) -> Gauge:
     return choices[prng.choice(len(choices), p=probabilites)]
 
@@ -154,12 +188,14 @@ class GaugeSelector:
 
 @transformer_api.transformer
 class GaugeTransformer:
+
     def __init__(
         self,
         # target can be either a specific gate, gatefamily or gateset
         # which allows matching parametric gates.
         target: Union[ops.Gate, ops.Gateset, ops.GateFamily],
         gauge_selector: Callable[[np.random.Generator], Gauge],
+        two_qubit_gate_symbolizer: Optional[TwoQubitGateSymbolizer] = None,
     ) -> None:
         """Constructs a GaugeTransformer.
 
@@ -167,9 +203,11 @@ class GaugeTransformer:
             target: Target two-qubit gate, a gate-family or a gate-set of two-qubit gates.
             gauge_selector: A callable that takes a numpy random number generator
                 as an argument and returns a Gauge.
+            two_qubit_gate_symbolizer: A symbolizer to symbolize 2 qubit gates.
         """
         self.target = ops.GateFamily(target) if isinstance(target, ops.Gate) else target
         self.gauge_selector = gauge_selector
+        self.two_qubit_gate_symbolizer = two_qubit_gate_symbolizer
 
     def __call__(
         self,
@@ -235,15 +273,24 @@ class GaugeTransformer:
         if context.deep:
             raise ValueError('GaugeTransformer cannot be used with deep=True')
         new_moments: List[List[ops.Operation]] = []  # Store parameterized circuits.
-        values_by_params: Dict[str, List[float]] = {}  # map from symbol name to N values.
-        symbol_count = count()
+        phxz_sid = itertools.count()
+        two_qubit_gate_sid = itertools.count()
         # Map from "((pre|post),$qid,$moment_id)" to gate parameters.
-        # E.g. {(post,q1,2): {"x_exponent": "x1", "z_exponent": "z1", "axis_phase": "a1"}}
-        symbols_by_loc: Dict[Tuple[str, ops.Qid, int], Dict[str, sympy.Symbol]] = {}
+        # E.g., {(post,q1,2): {"x_exponent": "x1", "z_exponent": "z1", "axis_phase": "a1"}}
+        phxz_symbols_by_locs: Dict[Tuple[str, ops.Qid, int], Dict[str, sympy.Symbol]] = {}
+        # Map from "($q0,$q1,$moment_id)" to gate parameters.
+        # E.g., {(q0,q1,0): ["s0"]}.
+        two_qubit_gate_symbols_by_locs: Dict[Tuple[ops.Qid, ops.Qid, int], List[sympy.Symbol]] = {}
 
         def single_qubit_next_symbol() -> Dict[str, sympy.Symbol]:
-            sid = next(symbol_count)
-            return _parameterize(1, sid)
+            sid = next(phxz_sid)
+            return _parameterize_to_phxz(sid)
+
+        def two_qubit_gate_next_symbol_list(n: int) -> List[sympy.Symbol]:
+            """Returns symbols for 2 qubit gate parameterization."""
+            sid = next(two_qubit_gate_sid)
+            symbols: List[sympy.Symbol] = [sympy.Symbol(f"s{sid}_{sub}") for sub in range(n)]
+            return symbols
 
         # Build parameterized circuit.
         for moment_id, moment in enumerate(circuit):
@@ -257,17 +304,29 @@ class GaugeTransformer:
                     center_moment.append(op)
                     continue
                 if op.gate is not None and op in self.target:
+                    random_gauge = self.gauge_selector(rng).sample(op.gate, rng)
+                    # Build symbols for 2-qubit-gates if the transformer might transform it,
+                    # otherwise, keep it as it is.
+                    if self.two_qubit_gate_symbolizer is not None:
+                        symbols: list[sympy.Symbol] = two_qubit_gate_next_symbol_list(
+                            self.two_qubit_gate_symbolizer.n_symbols
+                        )
+                        two_qubit_gate_symbols_by_locs[(op.qubits[0], op.qubits[1], moment_id)] = (
+                            symbols
+                        )
+                        parameterized_2_qubit_gate, _ = self.two_qubit_gate_symbolizer(
+                            random_gauge.two_qubit_gate, symbols
+                        )
+                        center_moment.append(parameterized_2_qubit_gate.on(*op.qubits))
+                    else:
+                        center_moment.append(op)
                     # Build symbols for the gauge, for a 2-qubit gauge, symbols will be built for
                     # pre/post q0/q1 and the new 2-qubit gate if the 2-qubit gate is updated in
                     # the gauge compiling.
-                    center_moment.append(op)
                     for prefix, q in itertools.product(["pre", "post"], op.qubits):
                         xza_by_symbols = single_qubit_next_symbol()  # xza in phased xz gate.
-                        loc = (prefix, q, moment_id)
-                        symbols_by_loc[loc] = xza_by_symbols
+                        phxz_symbols_by_locs[(prefix, q, moment_id)] = xza_by_symbols
                         new_op = ops.PhasedXZGate(**xza_by_symbols).on(q)
-                        for symbol in xza_by_symbols.values():
-                            values_by_params.update({str(symbol): []})
                         if prefix == "pre":
                             left_moment.append(new_op)
                         else:
@@ -278,6 +337,20 @@ class GaugeTransformer:
                 [moment for moment in [left_moment, center_moment, right_moment] if moment]
             )
 
+        # Initialize the map from symbol names to their N values.
+        values_by_params: Dict[str, List[float]] = {
+            **{
+                str(symbol): []
+                for symbols_by_names in phxz_symbols_by_locs.values()
+                for symbol in symbols_by_names.values()
+            },
+            **{
+                str(symbol): []
+                for symbols in two_qubit_gate_symbols_by_locs.values()
+                for symbol in symbols
+            },
+        }
+
         # Assign values for parameters via randomly chosen GaugeSelector.
         for _ in range(N):
             for moment_id, moment in enumerate(circuit):
@@ -288,17 +361,30 @@ class GaugeTransformer:
                         continue
                     if op.gate is not None and len(op.qubits) == 2 and op in self.target:
                         gauge = self.gauge_selector(rng).sample(op.gate, rng)
-                        if not gauge.support_sweep:
-                            raise NotImplementedError(
-                                f"as_sweep isn't supported for {gauge.two_qubit_gate} gauge"
+
+                        # Get the params for 2 qubit gates.
+                        if self.two_qubit_gate_symbolizer is not None:
+                            _, vals_by_symbols = self.two_qubit_gate_symbolizer(
+                                gauge.two_qubit_gate,
+                                [
+                                    *two_qubit_gate_symbols_by_locs[
+                                        (op.qubits[0], op.qubits[1], moment_id)
+                                    ]
+                                ],
                             )
+                            for symbol_str, val in vals_by_symbols.items():
+                                values_by_params[symbol_str].append(float(val))
+
                         # Get the params of pre/post q0/q1 gates.
                         for pre_or_post, idx in itertools.product(["pre", "post"], [0, 1]):
-                            symbols = symbols_by_loc[(pre_or_post, op.qubits[idx], moment_id)]
                             gates = getattr(gauge, f"{pre_or_post}_q{idx}")
-                            phxz_params = _gate_sequence_to_phxz_params(gates, symbols)
+                            phxz_params = _gate_sequence_to_phxz_params(
+                                gates,
+                                phxz_symbols_by_locs[(pre_or_post, op.qubits[idx], moment_id)],
+                            )
                             for key, value in phxz_params.items():
-                                values_by_params[key].append(value)
+                                values_by_params[key].append(float(value))
+
         sweeps: List[Points] = [
             Points(key=key, points=values) for key, values in values_by_params.items()
         ]
@@ -318,17 +404,16 @@ def _build_moments(operation_by_qubits: List[List[ops.Operation]]) -> List[List[
     return moments
 
 
-def _parameterize(num_qubits: int, symbol_id: int) -> Dict[str, sympy.Symbol]:
+def _parameterize_to_phxz(symbol_id: int) -> Dict[str, sympy.Symbol]:
     """Returns symbolized parameters for the gate."""
 
-    if num_qubits == 1:  # Convert single qubit gate to parameterized PhasedXZGate.
-        phased_xz_params = {
-            "x_exponent": sympy.Symbol(f"x{symbol_id}"),
-            "z_exponent": sympy.Symbol(f"z{symbol_id}"),
-            "axis_phase_exponent": sympy.Symbol(f"a{symbol_id}"),
-        }
-        return phased_xz_params
-    raise NotImplementedError("parameterization for non single qubit gates is not supported yet")
+    # Parameterize single qubit gate to parameterized PhasedXZGate.
+    phased_xz_params = {
+        "x_exponent": sympy.Symbol(f"x{symbol_id}"),
+        "z_exponent": sympy.Symbol(f"z{symbol_id}"),
+        "axis_phase_exponent": sympy.Symbol(f"a{symbol_id}"),
+    }
+    return phased_xz_params
 
 
 def _gate_sequence_to_phxz_params(

cirq/transformers/gauge_compiling/gauge_compiling_test.py

@@ -16,12 +16,16 @@ import unittest.mock
 import pytest
 import numpy as np
 import cirq
+import sympy
 from cirq.transformers.gauge_compiling import (
     GaugeTransformer,
     CZGaugeTransformer,
+    SqrtCZGaugeTransformer,
     ConstantGauge,
     GaugeSelector,
+    TwoQubitGateSymbolizer,
 )
+from cirq.transformers.gauge_compiling.sqrt_cz_gauge import SqrtCZGauge
 from cirq.transformers.analytical_decompositions import single_qubit_decompositions
 
 
@@ -64,7 +68,6 @@ def test_as_sweep_multi_pre_or_multi_post():
             gauges=[
                 ConstantGauge(
                     two_qubit_gate=cirq.CZ,
-                    support_sweep=True,
                     pre_q0=[cirq.X, cirq.X],
                     post_q0=[cirq.Z],
                     pre_q1=[cirq.Y],
@@ -91,7 +94,6 @@ def test_as_sweep_invalid_gauge_sequence():
             gauges=[
                 ConstantGauge(
                     two_qubit_gate=cirq.CZ,
-                    support_sweep=True,
                     pre_q0=[cirq.measure],
                     post_q0=[cirq.Z],
                     pre_q1=[cirq.X],
@@ -110,16 +112,33 @@ def test_as_sweep_convert_to_phxz_failed():
     qs = cirq.LineQubit.range(2)
     c = cirq.Circuit(cirq.CZ(*qs))
 
-    def mock_single_qubit_matrix_to_phxz(*args, **kwargs):
-        # Return an non PhasedXZ gate, so we expect errors from as_sweep().
-        return cirq.X
-
     with unittest.mock.patch.object(
         single_qubit_decompositions,
         "single_qubit_matrix_to_phxz",
-        new=mock_single_qubit_matrix_to_phxz,
+        # Return an non PhasedXZ gate, so we expect errors from as_sweep().
+        return_value=cirq.X,
     ):
         with pytest.raises(
             ValueError, match="Failed to convert the gate sequence to a PhasedXZ gate."
         ):
             _ = CZGaugeTransformer.as_sweep(c, context=cirq.TransformerContext(), N=1)
+
+
+def test_symbolize_2_qubits_gate_failed():
+    qs = cirq.LineQubit.range(2)
+    c = cirq.Circuit(cirq.CZPowGate(exponent=0.5).on(*qs))
+
+    with unittest.mock.patch.object(
+        SqrtCZGauge,
+        "sample",
+        # ISWAP gate is not a CZPowGate; errors are expected when symbolizing the 2-qubit gate.
+        return_value=ConstantGauge(two_qubit_gate=cirq.ISWAP),
+    ):
+        with pytest.raises(ValueError, match="Can't symbolize non-CZPowGate as CZ\\*\\*symbol."):
+            _ = SqrtCZGaugeTransformer.as_sweep(c, N=1)
+
+
+def test_symbolize_2_qubits_gate_failed_unmatched_symbol_length():
+    symbolizer = TwoQubitGateSymbolizer(symbolizer_fn=lambda gate, _: (gate, {}), n_symbols=2)
+    with pytest.raises(ValueError, match="Expect 2 symbols, but got 1 symbols"):
+        symbolizer(cirq.CZ, [sympy.Symbol('x')])

cirq/transformers/gauge_compiling/gauge_compiling_test_utils.py

@@ -27,7 +27,6 @@ class GaugeTester:
     two_qubit_gate: cirq.Gate
     gauge_transformer: GaugeTransformer
     must_fail: bool = False
-    sweep_must_pass: bool = False
 
     @pytest.mark.parametrize(
         ['generation_seed', 'transformation_seed'],
@@ -77,13 +76,6 @@ class GaugeTester:
     def test_sweep(self):
         qubits = cirq.LineQubit.range(3)
 
-        if not self.sweep_must_pass:
-            with pytest.raises(NotImplementedError):
-                self.gauge_transformer.as_sweep(
-                    cirq.Circuit(cirq.Moment(self.two_qubit_gate(*qubits[:2]))), N=1
-                )
-            return
-
         input_circuit = cirq.Circuit(
             cirq.Moment(cirq.H(qubits[0])),
             cirq.Moment(self.two_qubit_gate(*qubits[:2])),
@@ -104,6 +96,14 @@ class GaugeTester:
         # Check compilied circuits have the same unitary as the orig circuit.
         for params in sweeps:
             compiled_circuit = cirq.resolve_parameters(parameterized_circuit, params)
+            if self.must_fail:
+                with pytest.raises(AssertionError):
+                    cirq.testing.assert_circuits_have_same_unitary_given_final_permutation(
+                        input_circuit[:-1],
+                        compiled_circuit[:-1],
+                        qubit_map={q: q for q in input_circuit.all_qubits()},
+                    )
+                break
             cirq.testing.assert_circuits_have_same_unitary_given_final_permutation(
                 input_circuit[:-1],
                 compiled_circuit[:-1],

cirq/transformers/gauge_compiling/gauge_compiling_test_utils_test.py

@@ -48,22 +48,6 @@ _BAD_TRANSFORMER = GaugeTransformer(
     ),
 )
 
-_TRANSFORMER_WITH_SWEEP = GaugeTransformer(
-    target=_EXAMPLE_SWEEP_TARGET,
-    gauge_selector=GaugeSelector(
-        gauges=[
-            ConstantGauge(
-                two_qubit_gate=_EXAMPLE_SWEEP_TARGET,
-                pre_q0=cirq.Z,
-                pre_q1=cirq.Z,
-                post_q0=cirq.Z,
-                post_q1=cirq.Z,
-                support_sweep=True,
-            )
-        ]
-    ),
-)
-
 
 class TestValidTransformer(GaugeTester):
     two_qubit_gate = _EXAMPLE_TARGET
@@ -74,9 +58,3 @@ class TestInvalidTransformer(GaugeTester):
     two_qubit_gate = _EXAMPLE_TARGET
     gauge_transformer = _BAD_TRANSFORMER
     must_fail = True
-
-
-class TestSweep(GaugeTester):
-    two_qubit_gate = _EXAMPLE_SWEEP_TARGET
-    gauge_transformer = _TRANSFORMER_WITH_SWEEP
-    sweep_must_pass = True

cirq/transformers/gauge_compiling/iswap_gauge.py

@@ -56,7 +56,6 @@ class RZRotation(Gauge):
             pre_q1=n_rz if flip_diangonal else rz,
             post_q0=rz if flip_diangonal else n_rz,
             post_q1=n_rz,
-            support_sweep=True,
         )
 
     def sample(self, gate: ops.Gate, prng: np.random.Generator) -> ConstantGauge:
@@ -89,12 +88,7 @@ class XYRotation(Gauge):
         xy_a = self._xy(a)
         xy_b = self._xy(b)
         return ConstantGauge(
-            two_qubit_gate=ops.ISWAP,
-            pre_q0=xy_a,
-            pre_q1=xy_b,
-            post_q0=xy_b,
-            post_q1=xy_a,
-            support_sweep=True,
+            two_qubit_gate=ops.ISWAP, pre_q0=xy_a, pre_q1=xy_b, post_q0=xy_b, post_q1=xy_a
         )
 
     def sample(self, gate: ops.Gate, prng: np.random.Generator) -> ConstantGauge:

cirq/transformers/gauge_compiling/iswap_gauge_test.py

@@ -21,4 +21,3 @@ from cirq.transformers.gauge_compiling.gauge_compiling_test_utils import GaugeTe
 class TestISWAPGauge(GaugeTester):
     two_qubit_gate = cirq.ISWAP
     gauge_transformer = ISWAPGaugeTransformer
-    sweep_must_pass = True

cirq/transformers/gauge_compiling/spin_inversion_gauge.py

@@ -23,8 +23,8 @@ from cirq import ops
 
 SpinInversionGaugeSelector = GaugeSelector(
     gauges=[
-        SameGateGauge(pre_q0=ops.X, post_q0=ops.X, pre_q1=ops.X, post_q1=ops.X, support_sweep=True),
-        SameGateGauge(support_sweep=True),
+        SameGateGauge(pre_q0=ops.X, post_q0=ops.X, pre_q1=ops.X, post_q1=ops.X),
+        SameGateGauge(),
     ]
 )
 

cirq/transformers/gauge_compiling/sqrt_cz_gauge.py

@@ -15,16 +15,20 @@
 """A Gauge transformer for CZ**0.5 and CZ**-0.5 gates."""
 
 
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Dict, Sequence, Tuple
+from numbers import Real
 import numpy as np
+import sympy
 
 from cirq.transformers.gauge_compiling.gauge_compiling import (
     GaugeTransformer,
     GaugeSelector,
     ConstantGauge,
     Gauge,
+    TwoQubitGateSymbolizer,
 )
-from cirq.ops import CZ, S, X, Gateset
+from cirq.ops import CZ, S, X, Gateset, Gate, CZPowGate
+
 
 if TYPE_CHECKING:
     import cirq
@@ -59,6 +63,20 @@ class SqrtCZGauge(Gauge):
             )
 
 
+def _symbolize_as_cz_pow(
+    two_qubit_gate: Gate, symbols: Sequence[sympy.Symbol]
+) -> Tuple[Gate, Dict[str, Real]]:
+    """Symbolizes a CZPowGate to a parameterized CZPowGate."""
+
+    if not isinstance(two_qubit_gate, CZPowGate) or not isinstance(two_qubit_gate.exponent, Real):
+        raise ValueError("Can't symbolize non-CZPowGate as CZ**symbol.")
+    return (CZ ** symbols[0], {str(symbols[0]): two_qubit_gate.exponent})
+
+
 SqrtCZGaugeTransformer = GaugeTransformer(
-    target=Gateset(_SQRT_CZ, _SQRT_CZ**-1), gauge_selector=GaugeSelector(gauges=[SqrtCZGauge()])
+    target=Gateset(_SQRT_CZ, _SQRT_CZ**-1),
+    gauge_selector=GaugeSelector(gauges=[SqrtCZGauge()]),
+    two_qubit_gate_symbolizer=TwoQubitGateSymbolizer(
+        symbolizer_fn=_symbolize_as_cz_pow, n_symbols=1
+    ),
 )

cirq/transformers/gauge_compiling/sqrt_cz_gauge_test.py

@@ -20,8 +20,10 @@ from cirq.transformers.gauge_compiling.gauge_compiling_test_utils import GaugeTe
 class TestSqrtCZGauge(GaugeTester):
     two_qubit_gate = cirq.CZ**0.5
     gauge_transformer = SqrtCZGaugeTransformer
+    sweep_must_pass = True
 
 
 class TestAdjointSqrtCZGauge(GaugeTester):
     two_qubit_gate = cirq.CZ**-0.5
     gauge_transformer = SqrtCZGaugeTransformer
+    sweep_must_pass = True

cirq/transformers/gauge_compiling/sqrt_iswap_gauge.py

@@ -49,12 +49,7 @@ class RZRotation(Gauge):
         rz = ops.rz(theta)
         n_rz = ops.rz(-theta)
         return ConstantGauge(
-            two_qubit_gate=ops.SQRT_ISWAP,
-            pre_q0=rz,
-            pre_q1=rz,
-            post_q0=n_rz,
-            post_q1=n_rz,
-            support_sweep=True,
+            two_qubit_gate=ops.SQRT_ISWAP, pre_q0=rz, pre_q1=rz, post_q0=n_rz, post_q1=n_rz
         )
 
     def sample(self, gate: ops.Gate, prng: np.random.Generator) -> ConstantGauge:
@@ -85,12 +80,7 @@ class XYRotation(Gauge):
     def _xy_gauge(self, theta: float) -> ConstantGauge:
         xy = self._xy(theta)
         return ConstantGauge(
-            two_qubit_gate=ops.SQRT_ISWAP,
-            pre_q0=xy,
-            pre_q1=xy,
-            post_q0=xy,
-            post_q1=xy,
-            support_sweep=True,
+            two_qubit_gate=ops.SQRT_ISWAP, pre_q0=xy, pre_q1=xy, post_q0=xy, post_q1=xy
         )
 
     def sample(self, gate: ops.Gate, prng: np.random.Generator) -> ConstantGauge:

cirq/transformers/gauge_compiling/sqrt_iswap_gauge_test.py

@@ -20,4 +20,3 @@ from cirq.transformers.gauge_compiling.gauge_compiling_test_utils import GaugeTe
 class TestSqrtISWAPGauge(GaugeTester):
     two_qubit_gate = cirq.SQRT_ISWAP
     gauge_transformer = SqrtISWAPGaugeTransformer
-    sweep_must_pass = True

{cirq_core-1.5.0.dev20250118135200.dist-info → cirq_core-1.5.0.dev20250121182620.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cirq-core
-Version: 1.5.0.dev20250118135200
+Version: 1.5.0.dev20250121182620
 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

{cirq_core-1.5.0.dev20250118135200.dist-info → cirq_core-1.5.0.dev20250121182620.dist-info}/RECORD

@@ -4,10 +4,10 @@ cirq/_compat_test.py,sha256=Qq3ZcfgD-Nb81cEppQdJqhAyrVqXKtfXZYGXT0p-Wh0,34718
 cirq/_doc.py,sha256=yDyWUD_2JDS0gShfGRb-rdqRt9-WeL7DhkqX7np0Nko,2879
 cirq/_import.py,sha256=p9gMHJscbtDDkfHOaulvd3Aer0pwUF5AXpL89XR8dNw,8402
 cirq/_import_test.py,sha256=6K_v0riZJXOXUphHNkGA8MY-JcmGlezFaGmvrNhm3OQ,1015
-cirq/_version.py,sha256=xmqt47lnMTmm8rS7b1oeqZSno_8t-pGY6N7lNC_O4BI,1206
-cirq/_version_test.py,sha256=EufjKhDf5JWmc5U1tMdfnJrg6o6Py51fVvDT5Ag3yBU,147
+cirq/_version.py,sha256=XZdE7H_7w7Hiiirm6ued03JFp9knhCr9Q0kxSHi5gj4,1206
+cirq/_version_test.py,sha256=zc0zE4BdzIXGggkuzj7jYcjDGNVrkasDxCUOXtwbiU8,147
 cirq/conftest.py,sha256=X7yLFL8GLhg2CjPw0hp5e_dGASfvHx1-QT03aUbhKJw,1168
-cirq/json_resolver_cache.py,sha256=cpbvJMNIh0U-l1mEVb-TqhJUEXfm2vpuR3v432ORSmg,13702
+cirq/json_resolver_cache.py,sha256=p-vEOa-8GQ2cFIAdze-kd6C1un1uRvtujVPljVKaHBg,13557
 cirq/py.typed,sha256=VFSlmh_lNwnaXzwY-ZuW-C2Ws5PkuDoVgBdNCs0jXJE,63
 cirq/circuits/__init__.py,sha256=HKunqRpZoDmjy1IiK9Cn84MTGT84_PMeQ5VDCPafcWk,1335
 cirq/circuits/_block_diagram_drawer.py,sha256=06ceNV01cMx4irIGYnztfLt_HDNhK3AwfsiNh686hjU,9510
@@ -177,8 +177,6 @@ cirq/devices/unconstrained_device_test.py,sha256=OF9E2m1HPpq6hyrNAwFGWaNOpQ3H2ef
 cirq/experiments/__init__.py,sha256=Sx2sW3Uj0p7W-E_HkZ21YpHVUvKlp_zc5WWtago4rlo,3667
 cirq/experiments/fidelity_estimation.py,sha256=JK9yUoD4TL3nkf2yiEJ5f_RR-rhkAHSKpeLlYCRvZU4,9214
 cirq/experiments/fidelity_estimation_test.py,sha256=SX5hwQjyzWm1yr1q0C_LCgbFfUF_Ye36g6HuQbtinGI,4918
-cirq/experiments/grid_parallel_two_qubit_xeb.py,sha256=ROJZiXLaeF5IYo06DxeIvDHpwNJTIiqEAfKxs6v0vHM,2216
-cirq/experiments/grid_parallel_two_qubit_xeb_test.py,sha256=iDvDVsJxFp5xVlmse3EDH0Ok0-8yQpdAtQ2KHA7DbCY,1053
 cirq/experiments/n_qubit_tomography.py,sha256=9M_kf2-1hvFxfZOWND7ACwHYgD9SJU5nYFkeudQUlfE,8469
 cirq/experiments/n_qubit_tomography_test.py,sha256=wHfV2OpGYSDXfoyEh-B5dc1Dv8sxKNFbUoHyjIWZoFk,4362
 cirq/experiments/purity_estimation.py,sha256=6D1UwFlQRzHeajXMTyTUfBYAc0jJQ8Cfz4lteFKeUaM,2467
@@ -557,8 +555,6 @@ cirq/protocols/json_test_data/GridDeviceMetadata.repr,sha256=CUgbaLZ0862iK2mLS_T
 cirq/protocols/json_test_data/GridDeviceMetadata.repr_inward,sha256=5-tHgWDBLwj3pO9zk8PwFI2WVQehlNiuD-RpzzvqRmc,1483
 cirq/protocols/json_test_data/GridInteractionLayer.json,sha256=cknuXeHfwGozmVXd6THWPYekpzI8HnLWl5jXSkbI0A4,101
 cirq/protocols/json_test_data/GridInteractionLayer.repr,sha256=TiFgGlm8d2jCVCDzhx9cszrLQzcv-VPFK3LoQAan9B4,82
-cirq/protocols/json_test_data/GridParallelXEBMetadata.json,sha256=3Pg6vILyIg4_vBMfQHQk1z3tpe9_T2LdVXdYfz-HMeU,2093
-cirq/protocols/json_test_data/GridParallelXEBMetadata.repr,sha256=vbgITfQ0oHwNJyaB75qlkI_RTMCtJdnetmL0NvB2bPI,917
 cirq/protocols/json_test_data/GridQid.json,sha256=hWMrmU0ghYgnQbl68phBRJOa_KBUZIv0iTmXgmVpDqM,72
 cirq/protocols/json_test_data/GridQid.repr,sha256=XX1XEb941M6if3604YWq9WNgSfjUGD5NLYOpeBsUntI,33
 cirq/protocols/json_test_data/GridQubit.json,sha256=-NehjeVv5xBjj70mdVIQNwLCI6-p1RI0lGN75IK4srU,56
@@ -1105,21 +1101,21 @@ cirq/transformers/analytical_decompositions/two_qubit_to_ms.py,sha256=Awr7WvaJe_
 cirq/transformers/analytical_decompositions/two_qubit_to_ms_test.py,sha256=85MbuIAos7o1371wXs_KH-Bk6jsPqSBKAx9GJ9c-wVo,4160
 cirq/transformers/analytical_decompositions/two_qubit_to_sqrt_iswap.py,sha256=F_XpM4ApYHxV6hbWnV3C7Ud9L1BnpvBHBXShPh2mP3k,25397
 cirq/transformers/analytical_decompositions/two_qubit_to_sqrt_iswap_test.py,sha256=eKOzjWkR7xs-CL2oPj__nWXR0LL9oO42wEHibnvWq-o,20618
-cirq/transformers/gauge_compiling/__init__.py,sha256=ZF53ZtYRJeKsVJYjKc_QrAqE1pyd8FFmmb6Wo8JdgQs,1385
-cirq/transformers/gauge_compiling/cz_gauge.py,sha256=pJ41uVaUltigKLIayxr0XMqTYEs0zUDnaWD-tp65pPk,4198
+cirq/transformers/gauge_compiling/__init__.py,sha256=eG8ghJrue39O5Ijla_VhKrxhgr2oWGIXHEcMKqSRkCM,1439
+cirq/transformers/gauge_compiling/cz_gauge.py,sha256=TNZviXFu4j-lCF87QMGYVdb2RC_ePHLdI6FRCqh9go4,2550
 cirq/transformers/gauge_compiling/cz_gauge_test.py,sha256=sHEgEEI_z9-Ka5ChN2JmtoYcEHhNYHysOjGJzaaKkoA,881
-cirq/transformers/gauge_compiling/gauge_compiling.py,sha256=kNIJwyGchc1eVrsb1tzSkwm01_PVDYyLSL56mG8xlcA,15230
-cirq/transformers/gauge_compiling/gauge_compiling_test.py,sha256=Nm0Uxqrq1Y5puQep9UpKXK2zg9a3Dx2NSFArIxeawUg,4444
-cirq/transformers/gauge_compiling/gauge_compiling_test_utils.py,sha256=7RNZ6-xQ1iKjoNWTokgok7xTCeAnrQUzbpdBhdJZEfY,4933
-cirq/transformers/gauge_compiling/gauge_compiling_test_utils_test.py,sha256=cWEAP1EWbpHNp7wQPXLyT413raoG3aIg8aFod_aXAtQ,2340
-cirq/transformers/gauge_compiling/iswap_gauge.py,sha256=W2g2DXhN1OQbVL1UxBjvZa3YsRPMFAiaC-tvxKImSHU,3613
-cirq/transformers/gauge_compiling/iswap_gauge_test.py,sha256=HoeJgSJSrr3ARXDPP9uOb5z4fgvR94snTWGfqG7-yuE,893
-cirq/transformers/gauge_compiling/spin_inversion_gauge.py,sha256=wpZx2-FbBt2Eq9ORUzMYPqtuJcHkU_5PTcQFDRfwSBo,1124
+cirq/transformers/gauge_compiling/gauge_compiling.py,sha256=4g2IyjGqEHD7KkawXlprhNLfbeSyz3QdWIHPAjqeGFo,18846
+cirq/transformers/gauge_compiling/gauge_compiling_test.py,sha256=srpVkn1WlJh5SATk1UozZT2aLVwcykSNBpsJ8u4YCrk,5234
+cirq/transformers/gauge_compiling/gauge_compiling_test_utils.py,sha256=K49nP6OOi2Fga50RA-qwjgjnOMvuT9hqhJdhaQnriTM,5025
+cirq/transformers/gauge_compiling/gauge_compiling_test_utils_test.py,sha256=4Hc3oFInAtiZugWTL75jpGJTVTubKWWTk4uaTLvOEY0,1784
+cirq/transformers/gauge_compiling/iswap_gauge.py,sha256=UGJ_061h65Rfgb9LWREjxC8OSt01ZqP9TGnacL8VAuk,3500
+cirq/transformers/gauge_compiling/iswap_gauge_test.py,sha256=HEIIwKlX5ixau1e_etSUj5NvYOVTT-Gc3kuHcyKAeJ4,866
+cirq/transformers/gauge_compiling/spin_inversion_gauge.py,sha256=gfjSlQdo13GfBPlrkQoHPWWzouiV7yYr7JAaB85NSGY,1086
 cirq/transformers/gauge_compiling/spin_inversion_gauge_test.py,sha256=eQ65i1GovnL2-VmPumcFKMIjqE0Pee1PdmsO0XDGmW4,1400
-cirq/transformers/gauge_compiling/sqrt_cz_gauge.py,sha256=32OGTcYT3tBFEQ1GQlrssc1wtwCcSvk4ZC0I1XD1QXg,1869
-cirq/transformers/gauge_compiling/sqrt_cz_gauge_test.py,sha256=RwjadOOJfa2Qf7iryTIMJLPzeDMNqFkP6Tewjq68gJI,997
-cirq/transformers/gauge_compiling/sqrt_iswap_gauge.py,sha256=VnlO4eqy5Yx-cE_EO0JSV2iccyJnrp7WWgzPiF_cJGg,3288
-cirq/transformers/gauge_compiling/sqrt_iswap_gauge_test.py,sha256=n0so4a7TLvpL5CelBUExpA0dgGvfAVxLsqLxRpKqFYE,909
+cirq/transformers/gauge_compiling/sqrt_cz_gauge.py,sha256=XwqVMeJu8zYpW7SAWZgLLsLGtZWdPfJLtCBdpEoROLQ,2529
+cirq/transformers/gauge_compiling/sqrt_cz_gauge_test.py,sha256=rNQ8O9d17xHHmV5Ss1167sZcKGMhGEQV26PMnvB-gHQ,1051
+cirq/transformers/gauge_compiling/sqrt_iswap_gauge.py,sha256=dqQa-UWq31bE_jF3KMhU76sND5GuqTpEp9-wVuXdWVM,3126
+cirq/transformers/gauge_compiling/sqrt_iswap_gauge_test.py,sha256=0CLZoLw-WK3aKEIoaKBrQZ-qvaprOVLad-dVyWFmSiU,882
 cirq/transformers/heuristic_decompositions/__init__.py,sha256=_LEidXfFkmJicQapJVR1etyH1fLJ3ZwtBgq2M2_ECZI,926
 cirq/transformers/heuristic_decompositions/gate_tabulation_math_utils.py,sha256=j9bbiIbC2rvwG830gTTf9zr9C7RVA5Ilhka_ZNF-N7w,10785
 cirq/transformers/heuristic_decompositions/gate_tabulation_math_utils_test.py,sha256=N02nlz7tISYVArvWNILwg-hnDB5Y9PCHbwIxk42Afv8,1534
@@ -1203,8 +1199,8 @@ cirq/work/sampler.py,sha256=bE5tmVkcR6cZZMLETxDfHehdsYUMbx2RvBeIBetehI4,19187
 cirq/work/sampler_test.py,sha256=hL2UWx3dz2ukZVNxWftiKVvJcQoLplLZdQm-k1QcA40,13282
 cirq/work/zeros_sampler.py,sha256=x1C7cup66a43n-3tm8QjhiqJa07qcJW10FxNp9jJ59Q,2356
 cirq/work/zeros_sampler_test.py,sha256=JIkpBBFPJe5Ba4142vzogyWyboG1Q1ZAm0UVGgOoZn8,3279
-cirq_core-1.5.0.dev20250118135200.dist-info/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
-cirq_core-1.5.0.dev20250118135200.dist-info/METADATA,sha256=48c3voaYdGjIxkmTTXLjlZuvfz8ZmbSgK33aae54egA,2105
-cirq_core-1.5.0.dev20250118135200.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-cirq_core-1.5.0.dev20250118135200.dist-info/top_level.txt,sha256=Sz9iOxHU0IEMLSFGwiwOCaN2e9K-jFbBbtpPN1hB73g,5
-cirq_core-1.5.0.dev20250118135200.dist-info/RECORD,,
+cirq_core-1.5.0.dev20250121182620.dist-info/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
+cirq_core-1.5.0.dev20250121182620.dist-info/METADATA,sha256=La24Zt1W_AZjANNM5OI0aYbgAQ8aQMCGxi3_KCsagks,2105
+cirq_core-1.5.0.dev20250121182620.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+cirq_core-1.5.0.dev20250121182620.dist-info/top_level.txt,sha256=Sz9iOxHU0IEMLSFGwiwOCaN2e9K-jFbBbtpPN1hB73g,5
+cirq_core-1.5.0.dev20250121182620.dist-info/RECORD,,

cirq/experiments/grid_parallel_two_qubit_xeb.py

@@ -1,62 +0,0 @@
-# Copyright 2020 The Cirq Developers
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     https://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# 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.
-"""Remnants of Parallel two-qubit cross-entropy benchmarking on a grid.
-
-This module keeps GridParallelXEBMetadata around for JSON backwards compatibility.
-"""
-import dataclasses
-from typing import Optional, Sequence, TYPE_CHECKING
-from cirq.experiments.random_quantum_circuit_generation import GridInteractionLayer
-from cirq import protocols
-
-if TYPE_CHECKING:
-    import cirq
-
-
-LAYER_A = GridInteractionLayer(col_offset=0, vertical=True, stagger=True)
-LAYER_B = GridInteractionLayer(col_offset=1, vertical=True, stagger=True)
-LAYER_C = GridInteractionLayer(col_offset=1, vertical=False, stagger=True)
-LAYER_D = GridInteractionLayer(col_offset=0, vertical=False, stagger=True)
-
-
-@dataclasses.dataclass
-class GridParallelXEBMetadata:
-    """Metadata for a grid parallel XEB experiment.
-    Attributes:
-        data_collection_id: The data collection ID of the experiment.
-    """
-
-    qubits: Sequence['cirq.Qid']
-    two_qubit_gate: 'cirq.Gate'
-    num_circuits: int
-    repetitions: int
-    cycles: Sequence[int]
-    layers: Sequence[GridInteractionLayer]
-    seed: Optional[int]
-
-    def _json_dict_(self):
-        return protocols.dataclass_json_dict(self)
-
-    def __repr__(self) -> str:
-        return (
-            'cirq.experiments.grid_parallel_two_qubit_xeb.'
-            'GridParallelXEBMetadata('
-            f'qubits={self.qubits!r}, '
-            f'two_qubit_gate={self.two_qubit_gate!r}, '
-            f'num_circuits={self.num_circuits!r}, '
-            f'repetitions={self.repetitions!r}, '
-            f'cycles={self.cycles!r}, '
-            f'layers={self.layers!r}, '
-            f'seed={self.seed!r})'
-        )

cirq/experiments/grid_parallel_two_qubit_xeb_test.py

@@ -1,28 +0,0 @@
-# Copyright 2022 The Cirq Developers
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     https://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# 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 cirq.experiments.grid_parallel_two_qubit_xeb import GridParallelXEBMetadata, LAYER_A, LAYER_B
-import cirq
-
-
-def test_grid_parallel_xeb_metadata_repr():
-    metadata = GridParallelXEBMetadata(
-        qubits=cirq.GridQubit.square(2),
-        two_qubit_gate=cirq.ISWAP,
-        num_circuits=10,
-        repetitions=10_000,
-        cycles=[2, 4, 6, 8, 10],
-        layers=[LAYER_A, LAYER_B],
-        seed=1234,
-    )
-    cirq.testing.assert_equivalent_repr(metadata)

cirq/protocols/json_test_data/GridParallelXEBMetadata.json

@@ -1,119 +0,0 @@
-[
-  {
-    "cirq_type": "GridParallelXEBMetadata",
-    "qubits": [
-      {
-        "cirq_type": "GridQubit",
-        "row": 0,
-        "col": 0
-      },
-      {
-        "cirq_type": "GridQubit",
-        "row": 0,
-        "col": 1
-      },
-      {
-        "cirq_type": "GridQubit",
-        "row": 1,
-        "col": 0
-      },
-      {
-        "cirq_type": "GridQubit",
-        "row": 1,
-        "col": 1
-      }
-    ],
-    "two_qubit_gate": {
-      "cirq_type": "ISwapPowGate",
-      "exponent": 1.0,
-      "global_shift": 0.0
-    },
-    "num_circuits": 10,
-    "repetitions": 10000,
-    "cycles": [
-      2,
-      4,
-      6,
-      8,
-      10
-    ],
-    "layers": [
-      {
-        "cirq_type": "GridInteractionLayer",
-        "col_offset": 0,
-        "vertical": true,
-        "stagger": true
-      },
-      {
-        "cirq_type": "GridInteractionLayer",
-        "col_offset": 1,
-        "vertical": true,
-        "stagger": true
-      }
-    ],
-    "seed": 1234
-  },
-  {
-    "cirq_type": "GridParallelXEBMetadata",
-    "qubits": [
-      {
-        "cirq_type": "GridQubit",
-        "row": 0,
-        "col": 0
-      },
-      {
-        "cirq_type": "GridQubit",
-        "row": 0,
-        "col": 1
-      },
-      {
-        "cirq_type": "GridQubit",
-        "row": 0,
-        "col": 2
-      },
-      {
-        "cirq_type": "GridQubit",
-        "row": 1,
-        "col": 0
-      },
-      {
-        "cirq_type": "GridQubit",
-        "row": 1,
-        "col": 1
-      },
-      {
-        "cirq_type": "GridQubit",
-        "row": 1,
-        "col": 2
-      }
-    ],
-    "two_qubit_gate": {
-      "cirq_type": "CZPowGate",
-      "exponent": 1.0,
-      "global_shift": 0.0
-    },
-    "num_circuits": 50,
-    "repetitions": 1000,
-    "cycles": [
-      3,
-      6,
-      9,
-      12
-    ],
-    "layers": [
-      {
-        "cirq_type": "GridInteractionLayer",
-        "col_offset": 1,
-        "vertical": false,
-        "stagger": true
-      },
-      {
-        "cirq_type": "GridInteractionLayer",
-        "col_offset": 0,
-        "vertical": false,
-        "stagger": true
-      }
-    ],
-    "seed": null
-  }
-]

cirq/protocols/json_test_data/GridParallelXEBMetadata.repr

@@ -1 +0,0 @@
-[cirq.experiments.grid_parallel_two_qubit_xeb.GridParallelXEBMetadata(qubits=[cirq.GridQubit(0, 0), cirq.GridQubit(0, 1), cirq.GridQubit(1, 0), cirq.GridQubit(1, 1)], two_qubit_gate=cirq.ISWAP, num_circuits=10, repetitions=10000, cycles=[2, 4, 6, 8, 10], layers=[cirq.experiments.GridInteractionLayer(col_offset=0, vertical=True, stagger=True), cirq.experiments.GridInteractionLayer(col_offset=1, vertical=True, stagger=True)], seed=1234), cirq.experiments.grid_parallel_two_qubit_xeb.GridParallelXEBMetadata(qubits=[cirq.GridQubit(0, 0), cirq.GridQubit(0, 1), cirq.GridQubit(0, 2), cirq.GridQubit(1, 0), cirq.GridQubit(1, 1), cirq.GridQubit(1, 2)], two_qubit_gate=cirq.CZ, num_circuits=50, repetitions=1000, cycles=[3, 6, 9, 12], layers=[cirq.experiments.GridInteractionLayer(col_offset=1, vertical=False, stagger=True), cirq.experiments.GridInteractionLayer(col_offset=0, vertical=False, stagger=True)], seed=None)]