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

cirq/transformers/gauge_compiling/gauge_compiling.py

@@ -14,17 +14,24 @@
 
 """Creates the abstraction for gauge compiling as a cirq transformer."""
 
-from typing import Callable, Tuple, Optional, Sequence, Union, List
 import abc
-import itertools
 import functools
-
+import itertools
 from dataclasses import dataclass
-from attrs import frozen, field
-import numpy as np
+from numbers import Real
+from typing import Callable, Dict, List, Optional, Sequence, Tuple, Union
 
+import numpy as np
+import sympy
+from attrs import field, frozen
+
+from cirq import circuits, ops
+from cirq.protocols import unitary_protocol
+from cirq.protocols.has_unitary_protocol import has_unitary
+from cirq.study import sweepable
+from cirq.study.sweeps import Points, Zip
 from cirq.transformers import transformer_api
-from cirq import ops, circuits
+from cirq.transformers.analytical_decompositions import single_qubit_decompositions
 
 
 class Gauge(abc.ABC):
@@ -122,6 +129,43 @@ class SameGateGauge(Gauge):
         )
 
 
+@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)]
 
@@ -144,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.
 
@@ -157,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,
@@ -201,6 +249,148 @@ class GaugeTransformer:
                 new_moments.extend(_build_moments(right))
         return circuits.Circuit.from_moments(*new_moments)
 
+    def as_sweep(
+        self,
+        circuit: circuits.AbstractCircuit,
+        *,
+        N: int,
+        context: Optional[transformer_api.TransformerContext] = None,
+        prng: Optional[np.random.Generator] = None,
+    ) -> Tuple[circuits.AbstractCircuit, sweepable.Sweepable]:
+        """Generates a parameterized circuit with *N* sets of sweepable parameters.
+
+        Args:
+            circuit: The input circuit to be processed by gauge compiling.
+            N: The number of parameter sets to generate.
+            context: A `cirq.TransformerContext` storing common configurable options for
+                the transformers.
+            prng: A pseudo-random number generator to select a gauge within a gauge cluster.
+        """
+
+        rng = np.random.default_rng() if prng is None else prng
+        if context is None:
+            context = transformer_api.TransformerContext(deep=False)
+        if context.deep:
+            raise ValueError('GaugeTransformer cannot be used with deep=True')
+        new_moments: List[List[ops.Operation]] = []  # Store parameterized circuits.
+        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"}}
+        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(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):
+            center_moment: List[ops.Operation] = []
+            left_moment: List[ops.Operation] = []
+            right_moment: List[ops.Operation] = []
+            for op in moment:
+                if isinstance(op, ops.TaggedOperation) and set(op.tags).intersection(
+                    context.tags_to_ignore
+                ):
+                    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.
+                    for prefix, q in itertools.product(["pre", "post"], op.qubits):
+                        xza_by_symbols = single_qubit_next_symbol()  # xza in phased xz gate.
+                        phxz_symbols_by_locs[(prefix, q, moment_id)] = xza_by_symbols
+                        new_op = ops.PhasedXZGate(**xza_by_symbols).on(q)
+                        if prefix == "pre":
+                            left_moment.append(new_op)
+                        else:
+                            right_moment.append(new_op)
+                else:
+                    center_moment.append(op)
+            new_moments.extend(
+                [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):
+                for op in moment:
+                    if isinstance(op, ops.TaggedOperation) and set(op.tags).intersection(
+                        context.tags_to_ignore
+                    ):
+                        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)
+
+                        # 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]):
+                            gates = getattr(gauge, f"{pre_or_post}_q{idx}")
+                            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(float(value))
+
+        sweeps: List[Points] = [
+            Points(key=key, points=values) for key, values in values_by_params.items()
+        ]
+
+        return circuits.Circuit.from_moments(*new_moments), Zip(*sweeps)
+
 
 def _build_moments(operation_by_qubits: List[List[ops.Operation]]) -> List[List[ops.Operation]]:
     """Builds moments from a list of operations grouped by qubits.
@@ -212,3 +402,52 @@ def _build_moments(operation_by_qubits: List[List[ops.Operation]]) -> List[List[
     for moment in itertools.zip_longest(*operation_by_qubits):
         moments.append([op for op in moment if op is not None])
     return moments
+
+
+def _parameterize_to_phxz(symbol_id: int) -> Dict[str, sympy.Symbol]:
+    """Returns symbolized parameters for the gate."""
+
+    # 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(
+    gates: Tuple[ops.Gate, ...], xza_by_symbols: Dict[str, sympy.Symbol]
+) -> Dict[str, float]:
+    identity_gate_in_phxz = {
+        str(xza_by_symbols["x_exponent"]): 0.0,
+        str(xza_by_symbols["z_exponent"]): 0.0,
+        str(xza_by_symbols["axis_phase_exponent"]): 0.0,
+    }
+    if not gates:
+        return identity_gate_in_phxz
+    for gate in gates:
+        if not has_unitary(gate) or gate.num_qubits() != 1:
+            raise ValueError(
+                "Invalid gate sequence to be converted to PhasedXZGate."
+                f"Found incompatiable gate {gate} in sequence."
+            )
+    phxz = (
+        single_qubit_decompositions.single_qubit_matrix_to_phxz(
+            functools.reduce(
+                np.matmul, [unitary_protocol.unitary(gate) for gate in reversed(gates)]
+            )
+        )
+        or ops.I
+    )
+    if phxz is ops.I:  # Identity gate
+        return identity_gate_in_phxz
+    # Check the gate type, needs to be a PhasedXZ gate.
+    if not isinstance(phxz, ops.PhasedXZGate):
+        raise ValueError("Failed to convert the gate sequence to a PhasedXZ gate.")
+    if phxz is not None:
+        return {
+            str(xza_by_symbols["x_exponent"]): phxz.x_exponent,
+            str(xza_by_symbols["z_exponent"]): phxz.z_exponent,
+            str(xza_by_symbols["axis_phase_exponent"]): phxz.axis_phase_exponent,
+        }

cirq/transformers/gauge_compiling/gauge_compiling_test.py

@@ -12,10 +12,23 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import pytest
+import unittest.mock
+
 import numpy as np
+import pytest
+import sympy
+
 import cirq
-from cirq.transformers.gauge_compiling import GaugeTransformer, CZGaugeTransformer
+from cirq.transformers.analytical_decompositions import single_qubit_decompositions
+from cirq.transformers.gauge_compiling import (
+    ConstantGauge,
+    CZGaugeTransformer,
+    GaugeSelector,
+    GaugeTransformer,
+    SqrtCZGaugeTransformer,
+    TwoQubitGateSymbolizer,
+)
+from cirq.transformers.gauge_compiling.sqrt_cz_gauge import SqrtCZGauge
 
 
 def test_deep_transformation_not_supported():
@@ -25,10 +38,19 @@ def test_deep_transformation_not_supported():
             cirq.Circuit(), context=cirq.TransformerContext(deep=True)
         )
 
+    with pytest.raises(ValueError, match="cannot be used with deep=True"):
+        _ = GaugeTransformer(target=cirq.CZ, gauge_selector=lambda _: None).as_sweep(
+            cirq.Circuit(), context=cirq.TransformerContext(deep=True), N=1
+        )
+
 
 def test_ignore_tags():
     c = cirq.Circuit(cirq.CZ(*cirq.LineQubit.range(2)).with_tags('foo'))
     assert c == CZGaugeTransformer(c, context=cirq.TransformerContext(tags_to_ignore={"foo"}))
+    parameterized_circuit, _ = CZGaugeTransformer.as_sweep(
+        c, context=cirq.TransformerContext(tags_to_ignore={"foo"}), N=1
+    )
+    assert c == parameterized_circuit
 
 
 def test_target_can_be_gateset():
@@ -39,3 +61,86 @@ def test_target_can_be_gateset():
     )
     want = cirq.Circuit(cirq.Y.on_each(qs), cirq.CZ(*qs), cirq.X.on_each(qs))
     assert transformer(c, prng=np.random.default_rng(0)) == want
+
+
+def test_as_sweep_multi_pre_or_multi_post():
+    transformer = GaugeTransformer(
+        target=cirq.CZ,
+        gauge_selector=GaugeSelector(
+            gauges=[
+                ConstantGauge(
+                    two_qubit_gate=cirq.CZ,
+                    pre_q0=[cirq.X, cirq.X],
+                    post_q0=[cirq.Z],
+                    pre_q1=[cirq.Y],
+                    post_q1=[cirq.Y, cirq.Y, cirq.Y],
+                )
+            ]
+        ),
+    )
+    qs = cirq.LineQubit.range(2)
+    input_circuit = cirq.Circuit(cirq.CZ(*qs))
+    parameterized_circuit, sweeps = transformer.as_sweep(input_circuit, N=1)
+
+    for params in sweeps:
+        compiled_circuit = cirq.resolve_parameters(parameterized_circuit, params)
+        cirq.testing.assert_circuits_have_same_unitary_given_final_permutation(
+            input_circuit, compiled_circuit, qubit_map={q: q for q in input_circuit.all_qubits()}
+        )
+
+
+def test_as_sweep_invalid_gauge_sequence():
+    transfomer = GaugeTransformer(
+        target=cirq.CZ,
+        gauge_selector=GaugeSelector(
+            gauges=[
+                ConstantGauge(
+                    two_qubit_gate=cirq.CZ,
+                    pre_q0=[cirq.measure],
+                    post_q0=[cirq.Z],
+                    pre_q1=[cirq.X],
+                    post_q1=[cirq.Z],
+                )
+            ]
+        ),
+    )
+    qs = cirq.LineQubit.range(2)
+    c = cirq.Circuit(cirq.CZ(*qs))
+    with pytest.raises(ValueError, match="Invalid gate sequence to be converted to PhasedXZGate."):
+        transfomer.as_sweep(c, N=1)
+
+
+def test_as_sweep_convert_to_phxz_failed():
+    qs = cirq.LineQubit.range(2)
+    c = cirq.Circuit(cirq.CZ(*qs))
+
+    with unittest.mock.patch.object(
+        single_qubit_decompositions,
+        "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

@@ -14,12 +14,12 @@
 
 
 from unittest.mock import patch
-import pytest
 
 import numpy as np
+import pytest
 
 import cirq
-from cirq.transformers.gauge_compiling import GaugeTransformer, GaugeSelector
+from cirq.transformers.gauge_compiling import GaugeSelector, GaugeTransformer
 
 
 class GaugeTester:
@@ -73,6 +73,43 @@ class GaugeTester:
             else:
                 _check_equivalent_with_error_message(c, nc, gauge)
 
+    def test_sweep(self):
+        qubits = cirq.LineQubit.range(3)
+
+        input_circuit = cirq.Circuit(
+            cirq.Moment(cirq.H(qubits[0])),
+            cirq.Moment(self.two_qubit_gate(*qubits[:2])),
+            cirq.Moment(self.two_qubit_gate(*qubits[1:])),
+            cirq.Moment([cirq.H(q) for q in qubits]),
+            cirq.Moment([cirq.measure(q) for q in qubits]),
+        )
+
+        n_samples = 5
+        parameterized_circuit, sweeps = self.gauge_transformer.as_sweep(input_circuit, N=n_samples)
+
+        # Check the parameterized circuit and N set of parameters.
+        assert cirq.is_parameterized(parameterized_circuit)
+        simulator = cirq.Simulator()
+        results = simulator.run_sweep(parameterized_circuit, sweeps)
+        assert len(results) == n_samples
+
+        # 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],
+                qubit_map={q: q for q in input_circuit.all_qubits()},
+            )
+
 
 def _check_equivalent_with_error_message(c: cirq.AbstractCircuit, nc: cirq.AbstractCircuit, gauge):
     try:

cirq/transformers/gauge_compiling/gauge_compiling_test_utils_test.py

@@ -14,9 +14,10 @@
 
 
 import numpy as np
+
 import cirq
+from cirq.transformers import ConstantGauge, GaugeSelector, GaugeTransformer
 from cirq.transformers.gauge_compiling.gauge_compiling_test_utils import GaugeTester
-from cirq.transformers import GaugeTransformer, GaugeSelector, ConstantGauge
 
 
 class ExampleGate(cirq.testing.TwoQubitGate):
@@ -26,7 +27,15 @@ class ExampleGate(cirq.testing.TwoQubitGate):
         return self.unitary
 
 
+class ExampleSweepGate(cirq.testing.TwoQubitGate):
+    unitary = cirq.unitary(cirq.CZ)
+
+    def _unitary_(self) -> np.ndarray:
+        return self.unitary  # pragma: no cover
+
+
 _EXAMPLE_TARGET = ExampleGate()
+_EXAMPLE_SWEEP_TARGET = ExampleSweepGate()
 
 _GOOD_TRANSFORMER = GaugeTransformer(
     target=_EXAMPLE_TARGET,

cirq/transformers/gauge_compiling/iswap_gauge.py

@@ -16,13 +16,13 @@
 
 import numpy as np
 
+from cirq import ops
 from cirq.transformers.gauge_compiling.gauge_compiling import (
     ConstantGauge,
     Gauge,
-    GaugeTransformer,
     GaugeSelector,
+    GaugeTransformer,
 )
-from cirq import ops
 
 
 class RZRotation(Gauge):

cirq/transformers/gauge_compiling/spin_inversion_gauge.py

@@ -14,12 +14,12 @@
 
 """The spin inversion gauge transformer."""
 
+from cirq import ops
 from cirq.transformers.gauge_compiling.gauge_compiling import (
-    GaugeTransformer,
     GaugeSelector,
+    GaugeTransformer,
     SameGateGauge,
 )
-from cirq import ops
 
 SpinInversionGaugeSelector = GaugeSelector(
     gauges=[

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 numbers import Real
+from typing import Dict, Sequence, Tuple, TYPE_CHECKING
+
 import numpy as np
+import sympy
 
+from cirq.ops import CZ, CZPowGate, Gate, Gateset, S, X
 from cirq.transformers.gauge_compiling.gauge_compiling import (
-    GaugeTransformer,
-    GaugeSelector,
     ConstantGauge,
     Gauge,
+    GaugeSelector,
+    GaugeTransformer,
+    TwoQubitGateSymbolizer,
 )
-from cirq.ops import CZ, S, X, Gateset
 
 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_iswap_gauge.py

@@ -15,13 +15,14 @@
 """A Gauge transformer for SQRT_ISWAP gate."""
 
 import numpy as np
+
+from cirq import ops
 from cirq.transformers.gauge_compiling.gauge_compiling import (
     ConstantGauge,
     Gauge,
-    GaugeTransformer,
     GaugeSelector,
+    GaugeTransformer,
 )
-from cirq import ops
 
 
 class RZRotation(Gauge):

cirq/transformers/heuristic_decompositions/__init__.py

@@ -15,7 +15,7 @@
 """Utilities for heuristic decomposition of cirq gates."""
 
 from cirq.transformers.heuristic_decompositions.two_qubit_gate_tabulation import (
-    TwoQubitGateTabulation,
-    TwoQubitGateTabulationResult,
-    two_qubit_gate_product_tabulation,
+    TwoQubitGateTabulation as TwoQubitGateTabulation,
+    TwoQubitGateTabulationResult as TwoQubitGateTabulationResult,
+    two_qubit_gate_product_tabulation as two_qubit_gate_product_tabulation,
 )

cirq/transformers/heuristic_decompositions/gate_tabulation_math_utils.py

@@ -1,8 +1,9 @@
 # pylint: disable=wrong-or-nonexistent-copyright-notice
 import itertools
-from typing import Union, Sequence, Optional
+from typing import Optional, Sequence, Union
 
 import numpy as np
+
 from cirq.value import random_state
 
 _RealArraylike = Union[np.ndarray, float]

cirq/transformers/heuristic_decompositions/gate_tabulation_math_utils_test.py

@@ -5,9 +5,9 @@ import pytest
 import cirq
 from cirq import value
 from cirq.transformers.heuristic_decompositions.gate_tabulation_math_utils import (
-    weyl_chamber_mesh,
     kak_vector_infidelity,
     random_qubit_unitary,
+    weyl_chamber_mesh,
 )
 
 

cirq/transformers/heuristic_decompositions/two_qubit_gate_tabulation.py

@@ -14,21 +14,21 @@
 
 """Attempt to tabulate single qubit gates required to generate a target 2Q gate
 with a product A k A."""
+from dataclasses import dataclass
 from functools import reduce
 from typing import List, NamedTuple, Sequence, Tuple
 
-from dataclasses import dataclass
 import numpy as np
 
 import cirq
 from cirq import value
-from cirq._compat import proper_repr, proper_eq
+from cirq._compat import proper_eq, proper_repr
 from cirq.transformers.heuristic_decompositions.gate_tabulation_math_utils import (
     kak_vector_infidelity,
+    kak_vector_to_unitary,
+    random_qubit_unitary,
     vector_kron,
     weyl_chamber_mesh,
-    random_qubit_unitary,
-    kak_vector_to_unitary,
 )
 
 _SingleQubitGatePair = Tuple[np.ndarray, np.ndarray]