cirq-core 1.5.0.dev20241219205221__py3-none-any.whl → 1.5.0.dev20241221000556__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.dev20241219205221"
+__version__ = "1.5.0.dev20241221000556"

cirq/_version_test.py

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

cirq/experiments/z_phase_calibration.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 
 """Provides a method to do z-phase calibration for excitation-preserving gates."""
-from typing import Union, Optional, Sequence, Tuple, Dict, TYPE_CHECKING, Any
+from typing import Union, Optional, Sequence, Tuple, Dict, TYPE_CHECKING, Any, List
 import multiprocessing
 import multiprocessing.pool
 
@@ -22,7 +22,8 @@ import numpy as np
 
 from cirq.experiments import xeb_fitting
 from cirq.experiments.two_qubit_xeb import parallel_xeb_workflow
-from cirq import ops
+from cirq.transformers import transformer_api
+from cirq import ops, circuits, protocols
 
 if TYPE_CHECKING:
     import cirq
@@ -283,3 +284,84 @@ def plot_z_phase_calibration_result(
         ax.set_title('-'.join(str(q) for q in pair))
         ax.legend()
     return axes
+
+
+def _z_angles(old: ops.PhasedFSimGate, new: ops.PhasedFSimGate) -> Tuple[float, float, float]:
+    """Computes a set of possible 3 z-phases that result in the change in gamma, zeta, and chi."""
+    # This procedure is the inverse of PhasedFSimGate.from_fsim_rz
+    delta_gamma = new.gamma - old.gamma
+    delta_zeta = new.zeta - old.zeta
+    delta_chi = new.chi - old.chi
+    return (-delta_gamma + delta_chi, -delta_gamma - delta_zeta, delta_zeta - delta_chi)
+
+
+@transformer_api.transformer
+class CalibrationTransformer:
+
+    def __init__(
+        self,
+        target: 'cirq.Gate',
+        calibration_map: Dict[Tuple['cirq.Qid', 'cirq.Qid'], 'cirq.PhasedFSimGate'],
+    ):
+        """Create a CalibrationTransformer.
+
+        The transformer adds 3 ZPowGates around each calibrated gate to cancel the
+        effect of z-phases.
+
+        Args:
+            target: The target gate. Any gate matching this
+                will be replaced based on the content of `calibration_map`.
+            calibration_map:
+                A map mapping qubit pairs to calibrated gates. This is the output of
+                calling `calibrate_z_phases`.
+        """
+        self.target = target
+        if isinstance(target, ops.PhasedFSimGate):
+            self.target_as_fsim = target
+        elif (gate := ops.PhasedFSimGate.from_matrix(protocols.unitary(target))) is not None:
+            self.target_as_fsim = gate
+        else:
+            raise ValueError(f"{target} is not equivalent to a PhasedFSimGate")
+        self.calibration_map = calibration_map
+
+    def __call__(
+        self,
+        circuit: 'cirq.AbstractCircuit',
+        *,
+        context: Optional[transformer_api.TransformerContext] = None,
+    ) -> 'cirq.Circuit':
+        """Adds 3 ZPowGates around each calibrated gate to cancel the effect of Z phases.
+
+        Args:
+            circuit: Circuit to transform.
+            context: Optional transformer context (not used).
+
+        Returns:
+            New circuit with the extra ZPowGates.
+        """
+        new_moments: List[Union[List[cirq.Operation], 'cirq.Moment']] = []
+        for moment in circuit:
+            before = []
+            after = []
+            for op in moment:
+                if op.gate != self.target:
+                    # not a target.
+                    continue
+                assert len(op.qubits) == 2
+                gate = self.calibration_map.get(op.qubits, None) or self.calibration_map.get(
+                    op.qubits[::-1], None
+                )
+                if gate is None:
+                    # no calibration available.
+                    continue
+                angles = np.array(_z_angles(self.target_as_fsim, gate)) / np.pi
+                angles = -angles  # Take the negative to cancel the effect.
+                before.append(ops.Z(op.qubits[0]) ** angles[0])
+                before.append(ops.Z(op.qubits[1]) ** angles[1])
+                after.append(ops.Z(op.qubits[0]) ** angles[2])
+            if before:
+                new_moments.append(before)
+            new_moments.append(moment)
+            if after:
+                new_moments.append(after)
+        return circuits.Circuit.from_moments(*new_moments)

cirq/experiments/z_phase_calibration_test.py

@@ -22,6 +22,7 @@ from cirq.experiments.z_phase_calibration import (
     calibrate_z_phases,
     z_phase_calibration_workflow,
     plot_z_phase_calibration_result,
+    CalibrationTransformer,
 )
 from cirq.experiments.xeb_fitting import XEBPhasedFSimCharacterizationOptions
 
@@ -205,3 +206,33 @@ def test_plot_z_phase_calibration_result():
     np.testing.assert_allclose(axes[1].lines[0].get_xdata().astype(float), [1, 2, 3])
     np.testing.assert_allclose(axes[1].lines[0].get_ydata().astype(float), [0.6, 0.4, 0.1])
     np.testing.assert_allclose(axes[1].lines[1].get_ydata().astype(float), [0.7, 0.77, 0.8])
+
+
+@pytest.mark.parametrize('angles', 2 * np.pi * np.random.random((10, 10)))
+def test_transform_circuit(angles):
+    theta, phi = angles[:2]
+    old_zs = angles[2:6]
+    new_zs = angles[6:]
+    gate = cirq.PhasedFSimGate.from_fsim_rz(theta, phi, old_zs[:2], old_zs[2:])
+    fsim = cirq.PhasedFSimGate.from_fsim_rz(theta, phi, new_zs[:2], new_zs[2:])
+    c = cirq.Circuit(gate(cirq.q(0), cirq.q(1)))
+    replacement_map = {(cirq.q(1), cirq.q(0)): fsim}
+
+    new_circuit = CalibrationTransformer(gate, replacement_map)(c)
+
+    # we replace the old gate with the `fsim` gate the result should be that the overall
+    # unitary equals the unitary of the original (ideal) gate.
+    circuit_with_replacement_gate = cirq.Circuit(
+        op if op.gate != gate else fsim(*op.qubits) for op in new_circuit.all_operations()
+    )
+    np.testing.assert_allclose(cirq.unitary(circuit_with_replacement_gate), cirq.unitary(c))
+
+
+def test_transform_circuit_invalid_gate_raises():
+    with pytest.raises(ValueError, match="is not equivalent to a PhasedFSimGate"):
+        _ = CalibrationTransformer(cirq.XX, {})
+
+
+def test_transform_circuit_uncalibrated_gates_pass():
+    c = cirq.Circuit(cirq.CZ(cirq.q(0), cirq.q(1)), cirq.measure(cirq.q(0)))
+    assert c == CalibrationTransformer(cirq.CZ, {})(c)

cirq/ops/fsim_gate.py

@@ -347,6 +347,45 @@ class PhasedFSimGate(gate_features.InterchangeableQubitsGate, raw_types.Gate):
         chi = (b0 - b1 - a0 + a1) / 2.0
         return PhasedFSimGate(theta, zeta, chi, gamma, phi)
 
+    @staticmethod
+    def from_matrix(u: np.ndarray) -> Optional['PhasedFSimGate']:
+        """Contruct a PhasedFSimGate from unitary.
+
+        Args:
+            u: A unitary matrix representing a PhasedFSimGate.
+
+        Returns:
+            - Either PhasedFSimGate with the given unitary or None if
+                the matrix is not unitary or if doesn't represent a PhasedFSimGate.
+        """
+
+        gamma = np.angle(u[1, 1] * u[2, 2] - u[1, 2] * u[2, 1]) / -2
+        phi = -np.angle(u[3, 3]) - 2 * gamma
+        phased_cos_theta_2 = u[1, 1] * u[2, 2]
+        if phased_cos_theta_2 == 0:
+            # The zeta phase is multiplied with cos(theta),
+            # so if cos(theta) is zero then any value is possible.
+            zeta = 0
+        else:
+            zeta = np.angle(u[2, 2] / u[1, 1]) / 2
+
+        phased_sin_theta_2 = u[1, 2] * u[2, 1]
+        if phased_sin_theta_2 == 0:
+            # The chi phase is multiplied with sin(theta),
+            # so if sin(theta) is zero then any value is possible.
+            chi = 0
+        else:
+            chi = np.angle(u[1, 2] / u[2, 1]) / 2
+
+        theta = np.angle(
+            np.exp(1j * (gamma + zeta)) * u[1, 1] - np.exp(1j * (gamma - chi)) * u[1, 2]
+        )
+
+        gate = PhasedFSimGate(theta=theta, phi=phi, chi=chi, zeta=zeta, gamma=gamma)
+        if np.allclose(u, protocols.unitary(gate)):
+            return gate
+        return None
+
     @property
     def rz_angles_before(self) -> Tuple['cirq.TParamVal', 'cirq.TParamVal']:
         """Returns 2-tuple of phase angles applied to qubits before FSimGate."""

cirq/ops/fsim_gate_test.py

@@ -797,3 +797,24 @@ def test_phased_fsim_json_dict():
     assert cirq.PhasedFSimGate(
         theta=0.12, zeta=0.34, chi=0.56, gamma=0.78, phi=0.9
     )._json_dict_() == {'theta': 0.12, 'zeta': 0.34, 'chi': 0.56, 'gamma': 0.78, 'phi': 0.9}
+
+
+@pytest.mark.parametrize(
+    'gate',
+    [
+        cirq.CZ,
+        cirq.SQRT_ISWAP,
+        cirq.SQRT_ISWAP_INV,
+        cirq.ISWAP,
+        cirq.ISWAP_INV,
+        cirq.cphase(0.1),
+        cirq.CZ**0.2,
+    ],
+)
+def test_phase_fsim_from_matrix(gate):
+    u = cirq.unitary(gate)
+    np.testing.assert_allclose(cirq.unitary(cirq.PhasedFSimGate.from_matrix(u)), u, atol=1e-8)
+
+
+def test_phase_fsim_from_matrix_not_fsim_returns_none():
+    assert cirq.PhasedFSimGate.from_matrix(np.ones((4, 4))) is None

cirq/transformers/gauge_compiling/cz_gauge.py

@@ -24,22 +24,134 @@ 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),
-        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),
+        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,
+        ),
     ]
 )
 

cirq/transformers/gauge_compiling/cz_gauge_test.py

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

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
+from typing import Callable, Dict, Tuple, Optional, Sequence, Union, List
+from itertools import count
+from dataclasses import dataclass
 import abc
 import itertools
 import functools
+import sympy
 
-from dataclasses import dataclass
 from attrs import frozen, field
 import numpy as np
 
 from cirq.transformers import transformer_api
 from cirq import ops, circuits
+from cirq.study import sweepable
+from cirq.protocols import unitary_protocol
+from cirq.protocols.has_unitary_protocol import has_unitary
+from cirq.study.sweeps import Points, Zip
+from cirq.transformers.analytical_decompositions import single_qubit_decompositions
 
 
 class Gauge(abc.ABC):
@@ -72,6 +79,7 @@ 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
@@ -201,6 +209,100 @@ 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.
+        values_by_params: Dict[str, List[float]] = {}  # map from symbol name to N values.
+        symbol_count = 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]] = {}
+
+        def single_qubit_next_symbol() -> Dict[str, sympy.Symbol]:
+            sid = next(symbol_count)
+            return _parameterize(1, sid)
+
+        # 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:
+                    # 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
+                        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:
+                            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]
+            )
+
+        # 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)
+                        if not gauge.support_sweep:
+                            raise NotImplementedError(
+                                f"as_sweep isn't supported for {gauge.two_qubit_gate} gauge"
+                            )
+                        # 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)
+                            for key, value in phxz_params.items():
+                                values_by_params[key].append(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 +314,50 @@ 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(num_qubits: int, 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")
+
+
+def _gate_sequence_to_phxz_params(
+    gates: Tuple[ops.Gate, ...], xza_by_symbols: Dict[str, sympy.Symbol]
+) -> Dict[str, float]:
+    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 {
+            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,
+        }
+    # 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,17 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import unittest.mock
 import pytest
 import numpy as np
 import cirq
-from cirq.transformers.gauge_compiling import GaugeTransformer, CZGaugeTransformer
+from cirq.transformers.gauge_compiling import (
+    GaugeTransformer,
+    CZGaugeTransformer,
+    ConstantGauge,
+    GaugeSelector,
+)
+from cirq.transformers.analytical_decompositions import single_qubit_decompositions
 
 
 def test_deep_transformation_not_supported():
@@ -25,10 +32,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 +55,71 @@ 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,
+                    support_sweep=True,
+                    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,
+                    support_sweep=True,
+                    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))
+
+    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,
+    ):
+        with pytest.raises(
+            ValueError, match="Failed to convert the gate sequence to a PhasedXZ gate."
+        ):
+            _ = CZGaugeTransformer.as_sweep(c, context=cirq.TransformerContext(), N=1)

cirq/transformers/gauge_compiling/gauge_compiling_test_utils.py

@@ -27,6 +27,7 @@ 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'],
@@ -73,6 +74,42 @@ class GaugeTester:
             else:
                 _check_equivalent_with_error_message(c, nc, gauge)
 
+    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])),
+            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)
+            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

@@ -26,7 +26,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
+
+
 _EXAMPLE_TARGET = ExampleGate()
+_EXAMPLE_SWEEP_TARGET = ExampleSweepGate()
 
 _GOOD_TRANSFORMER = GaugeTransformer(
     target=_EXAMPLE_TARGET,
@@ -40,6 +48,22 @@ _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
@@ -50,3 +74,9 @@ 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_core-1.5.0.dev20241219205221.dist-info → cirq_core-1.5.0.dev20241221000556.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cirq-core
-Version: 1.5.0.dev20241219205221
+Version: 1.5.0.dev20241221000556
 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.dev20241219205221.dist-info → cirq_core-1.5.0.dev20241221000556.dist-info}/RECORD

@@ -4,8 +4,8 @@ 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=LgYBHy4-TNt8aWBSL-jhQ7q-NeQUCK8I9jbPHuvcE2M,1206
-cirq/_version_test.py,sha256=iRVS_dYH5tfWJBzIJnvIXBfnhMrAk9rshfCOdmo5Bz0,147
+cirq/_version.py,sha256=OqoCeE--Ab9NG2PKQn-oiComWbF_Pgw1sRYHYc8sEY0,1206
+cirq/_version_test.py,sha256=UMG2gtNTe_70vsxwkOgm2BvpCnF9uav4WLuoPUqXTjY,147
 cirq/conftest.py,sha256=X7yLFL8GLhg2CjPw0hp5e_dGASfvHx1-QT03aUbhKJw,1168
 cirq/json_resolver_cache.py,sha256=03MVo6Y-UYrzt9CKHmwpiBLN2ixL6uSU-OWnKZXfG7k,13302
 cirq/py.typed,sha256=VFSlmh_lNwnaXzwY-ZuW-C2Ws5PkuDoVgBdNCs0jXJE,63
@@ -203,8 +203,8 @@ cirq/experiments/xeb_sampling.py,sha256=6ZOidGi7Kt6p4cMQCjK7qQuIUXVHCYl47B2GnL8M
 cirq/experiments/xeb_sampling_test.py,sha256=0XkQGvcURsug3IblE_wZrHVDoOQV3WuQilrqCJbDHjI,6784
 cirq/experiments/xeb_simulation.py,sha256=yML2NAnYTRFG1wsQHvxtNEGEMXuExbWjrE2JYuCqnrk,5076
 cirq/experiments/xeb_simulation_test.py,sha256=YWFKXPdtBFuZNhQoG06W1EetVhXighc3zyXwhKfGAeo,5652
-cirq/experiments/z_phase_calibration.py,sha256=6N83Ky3zkhT5LMKx0TqNe2UAQbb-rp4nzuTG31GFELg,11884
-cirq/experiments/z_phase_calibration_test.py,sha256=Hk6FR-mvlkwol1WQvc75gw6oC_adRW-0_JF5y0X598E,7592
+cirq/experiments/z_phase_calibration.py,sha256=2mkpmtY60hQuaB91If6eAL_q_nW88hwJ2Pqdq9R_iTE,15152
+cirq/experiments/z_phase_calibration_test.py,sha256=BJ88waxTxRUsKSoFnkYkvhKxKwBNSmYCuZII6X-R36g,8904
 cirq/interop/__init__.py,sha256=Xt1xU9UegP_jBNa9xaeOFSgtC0lYb_HNHq4hQQ0J20k,784
 cirq/interop/quirk/__init__.py,sha256=W11jqaExSgvoUkjM_d0Kik4R8bqETF9Ezo27CDEB3iw,1237
 cirq/interop/quirk/url_to_circuit.py,sha256=1ToWnFJdJIhCko9q62BEvOoCGxCpOUl8891IdCa52MM,14211
@@ -292,8 +292,8 @@ cirq/ops/eigen_gate.py,sha256=eQ6-MOknop7CrejsTuQ0KZWf4mZnQBi8wEaTQXw4KSQ,18334
 cirq/ops/eigen_gate_test.py,sha256=-7l6GmAd1EYzHoGREQN1n7J1VOQKbThH2mA88TRODs8,13928
 cirq/ops/fourier_transform.py,sha256=pynO07OcZSVCeL8L0pNQ9m_y5_wrpTWOMf99BHpjXdU,7579
 cirq/ops/fourier_transform_test.py,sha256=PIK4bWnCIy2TuX0fgclHeU1CBDT6zRVoQpv1v1jt62c,6220
-cirq/ops/fsim_gate.py,sha256=eAQP2XPWW_1nItjzv__75eqhruCbKkFB1Y_eL1ov10c,18725
-cirq/ops/fsim_gate_test.py,sha256=owW1VpXntJqxlzhtppnyfaS9gQKFNA6UzCHksgPHaHU,25165
+cirq/ops/fsim_gate.py,sha256=Avzlcb_O201K0_tBmNR5m9fWkpBM7Nby0MfJjNJ9g_8,20136
+cirq/ops/fsim_gate_test.py,sha256=4kFk0ALzTmaskQURHPl6JerNvw8gbZn49nt1_WAjpdY,25671
 cirq/ops/gate_features.py,sha256=414mSi3kgKSwLOeAG_WEZKn8ZMaLtOowed7os1qSnM4,1049
 cirq/ops/gate_features_test.py,sha256=mnlqJnSpllcOnTUdvmUs_ssnPRhAIgHhKIAK2Z86Dfg,2347
 cirq/ops/gate_operation.py,sha256=IGCyqe9YguIlajnQ3EV61Y0vUxOT_SrRxvNEFwKtUak,13720
@@ -1092,12 +1092,12 @@ cirq/transformers/analytical_decompositions/two_qubit_to_ms_test.py,sha256=85Mbu
 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=TNZviXFu4j-lCF87QMGYVdb2RC_ePHLdI6FRCqh9go4,2550
-cirq/transformers/gauge_compiling/cz_gauge_test.py,sha256=_2RMzwuMoqytgsVZEET2m6QsGoZ2_uWgBfSGGvhZEWo,854
-cirq/transformers/gauge_compiling/gauge_compiling.py,sha256=7jUg2MHVX2V8SzH7r27e_BUUA_p5l15-Qv8lLlhGasQ,7948
-cirq/transformers/gauge_compiling/gauge_compiling_test.py,sha256=xVeoaaMuenlp_pxqmZO89kJEeBV0iapK7-JDTUuC7Lg,1565
-cirq/transformers/gauge_compiling/gauge_compiling_test_utils.py,sha256=6mpF2ftcDtWQEsZNr-m16GkDOn5WBWV08JB4ZS5rf8M,3408
-cirq/transformers/gauge_compiling/gauge_compiling_test_utils_test.py,sha256=HQw1xeko9OAD0PCuKcehUiy8mbxeRza4nE-6E8MGVME,1584
+cirq/transformers/gauge_compiling/cz_gauge.py,sha256=pJ41uVaUltigKLIayxr0XMqTYEs0zUDnaWD-tp65pPk,4198
+cirq/transformers/gauge_compiling/cz_gauge_test.py,sha256=sHEgEEI_z9-Ka5ChN2JmtoYcEHhNYHysOjGJzaaKkoA,881
+cirq/transformers/gauge_compiling/gauge_compiling.py,sha256=MyzYcgr0vl0pzOq41jkzmrM6COsDg7e2iU_xQcUoQ20,15063
+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=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
@@ -1189,8 +1189,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.dev20241219205221.dist-info/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
-cirq_core-1.5.0.dev20241219205221.dist-info/METADATA,sha256=sUEl9aQuRY9clOGfxIhMygmHjCE89UTc7hGDjel2gHM,1992
-cirq_core-1.5.0.dev20241219205221.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-cirq_core-1.5.0.dev20241219205221.dist-info/top_level.txt,sha256=Sz9iOxHU0IEMLSFGwiwOCaN2e9K-jFbBbtpPN1hB73g,5
-cirq_core-1.5.0.dev20241219205221.dist-info/RECORD,,
+cirq_core-1.5.0.dev20241221000556.dist-info/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
+cirq_core-1.5.0.dev20241221000556.dist-info/METADATA,sha256=P70dL9Vm3tnlLFwyneVhZiRBS6axK3zAqZcEOrgNckg,1992
+cirq_core-1.5.0.dev20241221000556.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+cirq_core-1.5.0.dev20241221000556.dist-info/top_level.txt,sha256=Sz9iOxHU0IEMLSFGwiwOCaN2e9K-jFbBbtpPN1hB73g,5
+cirq_core-1.5.0.dev20241221000556.dist-info/RECORD,,