cirq-core 1.4.0.dev20240402234712__py3-none-any.whl → 1.4.0.dev20240403011731__py3-none-any.whl

cirq/_version.py

@@ -1 +1 @@
-__version__ = "1.4.0.dev20240402234712"
+__version__ = "1.4.0.dev20240403011731"

cirq/sim/state_vector_simulator.py

@@ -16,6 +16,7 @@
 import abc
 from functools import cached_property
 from typing import Any, Dict, Iterator, Sequence, Type, TYPE_CHECKING, Generic, TypeVar
+import warnings
 
 import numpy as np
 
@@ -124,7 +125,16 @@ class StateVectorTrialResult(
 
     @cached_property
     def final_state_vector(self) -> np.ndarray:
-        return self._get_merged_sim_state().target_tensor.reshape(-1)
+        ret = self._get_merged_sim_state().target_tensor.reshape(-1)
+        norm = np.linalg.norm(ret)
+        if abs(norm - 1) > np.sqrt(np.finfo(ret.dtype).eps):
+            warnings.warn(
+                f"final state vector's {norm=} is too far from 1,"
+                f" {abs(norm-1)} > {np.sqrt(np.finfo(ret.dtype).eps)}."
+                "skipping renormalization"
+            )
+            return ret
+        return ret / norm
 
     def state_vector(self, copy: bool = False) -> np.ndarray:
         """Return the state vector at the end of the computation.

cirq/transformers/__init__.py

@@ -119,3 +119,16 @@ from cirq.transformers.transformer_primitives import (
     unroll_circuit_op_greedy_earliest,
     unroll_circuit_op_greedy_frontier,
 )
+
+
+from cirq.transformers.gauge_compiling import (
+    CZGaugeTransformer,
+    ConstantGauge,
+    Gauge,
+    GaugeSelector,
+    GaugeTransformer,
+    ISWAPGaugeTransformer,
+    SpinInversionGaugeTransformer,
+    SqrtCZGaugeTransformer,
+    SqrtISWAPGaugeTransformer,
+)

cirq/transformers/gauge_compiling/__init__.py

@@ -0,0 +1,26 @@
+# Copyright 2024 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.transformers.gauge_compiling.gauge_compiling import (
+    ConstantGauge,
+    Gauge,
+    GaugeSelector,
+    GaugeTransformer,
+)
+from cirq.transformers.gauge_compiling.sqrt_cz_gauge import SqrtCZGaugeTransformer
+from cirq.transformers.gauge_compiling.spin_inversion_gauge import SpinInversionGaugeTransformer
+from cirq.transformers.gauge_compiling.cz_gauge import CZGaugeTransformer
+from cirq.transformers.gauge_compiling.iswap_gauge import ISWAPGaugeTransformer
+from cirq.transformers.gauge_compiling.sqrt_iswap_gauge import SqrtISWAPGaugeTransformer

cirq/transformers/gauge_compiling/cz_gauge.py

@@ -0,0 +1,46 @@
+# Copyright 2024 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.
+
+"""A Gauge Transformer for the CZ gate."""
+
+from cirq.transformers.gauge_compiling.gauge_compiling import (
+    GaugeTransformer,
+    GaugeSelector,
+    ConstantGauge,
+)
+from cirq.ops.common_gates import CZ
+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),
+    ]
+)
+
+CZGaugeTransformer = GaugeTransformer(target=CZ, gauge_selector=CZGaugeSelector)

cirq/transformers/gauge_compiling/cz_gauge_test.py

@@ -0,0 +1,23 @@
+# Copyright 2024 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.
+
+
+import cirq
+from cirq.transformers.gauge_compiling import CZGaugeTransformer
+from cirq.transformers.gauge_compiling.gauge_compiling_test_utils import GaugeTester
+
+
+class TestCZGauge(GaugeTester):
+    two_qubit_gate = cirq.CZ
+    gauge_transformer = CZGaugeTransformer

cirq/transformers/gauge_compiling/gauge_compiling.py

@@ -0,0 +1,178 @@
+# Copyright 2024 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.
+
+"""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
+
+from dataclasses import dataclass
+from attrs import frozen, field
+import numpy as np
+
+from cirq.transformers import transformer_api
+from cirq import ops, circuits
+
+
+class Gauge(abc.ABC):
+    """A gauge replaces a two qubit gate with an equivalent subcircuit.
+    0: pre_q0───────two_qubit_gate───────post_q0
+                        |
+    1: pre_q1───────two_qubit_gate───────post_q1
+
+    The Gauge class in general represents a family of closely related gauges
+    (e.g. random z-rotations); Use `sample` method to get a specific gauge.
+    """
+
+    def weight(self) -> float:
+        """Returns the relative frequency for selecting this gauge."""
+        return 1.0
+
+    @abc.abstractmethod
+    def sample(self, gate: ops.Gate, prng: np.random.Generator) -> "ConstantGauge":
+        """Returns a ConstantGauge sampled from a family of gauges.
+
+        Args:
+            gate: The two qubit gate to replace.
+            prng: A numpy random number generator.
+
+        Returns:
+            A ConstantGauge.
+        """
+
+
+@frozen
+class ConstantGauge(Gauge):
+    """A gauge that replaces a two qubit gate with a constant gauge."""
+
+    two_qubit_gate: ops.Gate
+    pre_q0: Tuple[ops.Gate, ...] = field(
+        default=(), converter=lambda g: (g,) if isinstance(g, ops.Gate) else tuple(g)
+    )
+    pre_q1: Tuple[ops.Gate, ...] = field(
+        default=(), converter=lambda g: (g,) if isinstance(g, ops.Gate) else tuple(g)
+    )
+    post_q0: Tuple[ops.Gate, ...] = field(
+        default=(), converter=lambda g: (g,) if isinstance(g, ops.Gate) else tuple(g)
+    )
+    post_q1: Tuple[ops.Gate, ...] = field(
+        default=(), converter=lambda g: (g,) if isinstance(g, ops.Gate) else tuple(g)
+    )
+
+    def sample(self, gate: ops.Gate, prng: np.random.Generator) -> "ConstantGauge":
+        return self
+
+    @property
+    def pre(self) -> Tuple[Tuple[ops.Gate, ...], Tuple[ops.Gate, ...]]:
+        """A tuple (ops to apply to q0, ops to apply to q1)."""
+        return self.pre_q0, self.pre_q1
+
+    @property
+    def post(self) -> Tuple[Tuple[ops.Gate, ...], Tuple[ops.Gate, ...]]:
+        """A tuple (ops to apply to q0, ops to apply to q1)."""
+        return self.post_q0, self.post_q1
+
+
+def _select(choices: Sequence[Gauge], probabilites: np.ndarray, prng: np.random.Generator) -> Gauge:
+    return choices[prng.choice(len(choices), p=probabilites)]
+
+
+@dataclass(frozen=True)
+class GaugeSelector:
+    """Samples a gauge from a list of gauges."""
+
+    gauges: Sequence[Gauge]
+
+    @functools.cached_property
+    def _weights(self) -> np.ndarray:
+        weights = np.array([g.weight() for g in self.gauges])
+        return weights / np.sum(weights)
+
+    def __call__(self, prng: np.random.Generator) -> Gauge:
+        """Randomly selects a gauge with probability proportional to its weight."""
+        return _select(self.gauges, self._weights, prng)
+
+
+@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],
+    ) -> None:
+        """Constructs a GaugeTransformer.
+
+        Args:
+            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.
+        """
+        self.target = ops.GateFamily(target) if isinstance(target, ops.Gate) else target
+        self.gauge_selector = gauge_selector
+
+    def __call__(
+        self,
+        circuit: circuits.AbstractCircuit,
+        *,
+        context: Optional[transformer_api.TransformerContext] = None,
+        prng: Optional[np.random.Generator] = None,
+    ) -> circuits.AbstractCircuit:
+        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 = []
+        left: List[List[ops.Operation]] = []
+        right: List[List[ops.Operation]] = []
+        for moment in circuit:
+            left.clear()
+            right.clear()
+            center: List[ops.Operation] = []
+            for op in moment:
+                if isinstance(op, ops.TaggedOperation) and set(op.tags).intersection(
+                    context.tags_to_ignore
+                ):
+                    center.append(op)
+                    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)
+                    q0, q1 = op.qubits
+                    left.extend([g(q) for g in gs] for q, gs in zip(op.qubits, gauge.pre))
+                    center.append(gauge.two_qubit_gate(q0, q1))
+                    right.extend([g(q) for g in gs] for q, gs in zip(op.qubits, gauge.post))
+                else:
+                    center.append(op)
+            if left:
+                new_moments.extend(_build_moments(left))
+            new_moments.append(center)
+            if right:
+                new_moments.extend(_build_moments(right))
+        return circuits.Circuit.from_moments(*new_moments)
+
+
+def _build_moments(operation_by_qubits: List[List[ops.Operation]]) -> List[List[ops.Operation]]:
+    """Builds moments from a list of operations grouped by qubits.
+
+    Returns a list of moments from a list whose ith element is a list of operations applied
+    to qubit i.
+    """
+    moments = []
+    for moment in itertools.zip_longest(*operation_by_qubits):
+        moments.append([op for op in moment if op is not None])
+    return moments

cirq/transformers/gauge_compiling/gauge_compiling_test.py

@@ -0,0 +1,41 @@
+# Copyright 2024 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.
+
+import pytest
+import numpy as np
+import cirq
+from cirq.transformers.gauge_compiling import GaugeTransformer, CZGaugeTransformer
+
+
+def test_deep_transformation_not_supported():
+
+    with pytest.raises(ValueError, match="cannot be used with deep=True"):
+        _ = GaugeTransformer(target=cirq.CZ, gauge_selector=lambda _: None)(
+            cirq.Circuit(), context=cirq.TransformerContext(deep=True)
+        )
+
+
+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"}))
+
+
+def test_target_can_be_gateset():
+    qs = cirq.LineQubit.range(2)
+    c = cirq.Circuit(cirq.CZ(*qs))
+    transformer = GaugeTransformer(
+        target=cirq.Gateset(cirq.CZ), gauge_selector=CZGaugeTransformer.gauge_selector
+    )
+    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

cirq/transformers/gauge_compiling/gauge_compiling_test_utils.py

@@ -0,0 +1,83 @@
+# Copyright 2024 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 unittest.mock import patch
+import pytest
+
+import numpy as np
+
+import cirq
+from cirq.transformers.gauge_compiling import GaugeTransformer, GaugeSelector
+
+
+class GaugeTester:
+
+    two_qubit_gate: cirq.Gate
+    gauge_transformer: GaugeTransformer
+    must_fail: bool = False
+
+    @pytest.mark.parametrize(
+        ['generation_seed', 'transformation_seed'],
+        np.random.RandomState(0).randint(2**31, size=(5, 2)).tolist(),
+    )
+    def test_gauge_transformer(self, generation_seed, transformation_seed):
+        c = cirq.Circuit()
+        while not any(op.gate == self.two_qubit_gate for op in c.all_operations()):
+            c = cirq.testing.random_circuit(
+                qubits=3,
+                n_moments=3,
+                op_density=1,
+                gate_domain={self.two_qubit_gate: 2, cirq.X: 1, cirq.Y: 1, cirq.H: 1, cirq.Z: 1},
+                random_state=generation_seed,
+            )
+            generation_seed += 1
+        nc = self.gauge_transformer(c, prng=np.random.default_rng(transformation_seed))
+        if self.must_fail:
+            with pytest.raises(AssertionError):
+                cirq.testing.assert_circuits_have_same_unitary_given_final_permutation(
+                    nc, c, qubit_map={q: q for q in c.all_qubits()}
+                )
+        else:
+            cirq.testing.assert_circuits_have_same_unitary_given_final_permutation(
+                nc, c, qubit_map={q: q for q in c.all_qubits()}
+            )
+
+    @patch('cirq.transformers.gauge_compiling.gauge_compiling._select', autospec=True)
+    @pytest.mark.parametrize('seed', range(5))
+    def test_all_gauges(self, mock_select, seed):
+        assert isinstance(
+            self.gauge_transformer.gauge_selector, GaugeSelector
+        ), 'When using a custom selector, please override this method to properly test all gauges'
+        c = cirq.Circuit(self.two_qubit_gate(cirq.LineQubit(0), cirq.LineQubit(1)))
+        prng = np.random.default_rng(seed)
+        for gauge in self.gauge_transformer.gauge_selector.gauges:
+            mock_select.return_value = gauge
+            assert self.gauge_transformer.gauge_selector(prng) == gauge
+            nc = self.gauge_transformer(c, prng=prng)
+
+            if self.must_fail:
+                with pytest.raises(AssertionError):
+                    _check_equivalent_with_error_message(c, nc, gauge)
+            else:
+                _check_equivalent_with_error_message(c, nc, gauge)
+
+
+def _check_equivalent_with_error_message(c: cirq.AbstractCircuit, nc: cirq.AbstractCircuit, gauge):
+    try:
+        cirq.testing.assert_circuits_have_same_unitary_given_final_permutation(
+            nc, c, qubit_map={q: q for q in c.all_qubits()}
+        )
+    except AssertionError as ex:
+        raise AssertionError(f"{gauge=} didn't result in an equivalent circuit") from ex

cirq/transformers/gauge_compiling/gauge_compiling_test_utils_test.py

@@ -0,0 +1,52 @@
+# Copyright 2024 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.
+
+
+import numpy as np
+import cirq
+from cirq.transformers.gauge_compiling.gauge_compiling_test_utils import GaugeTester
+from cirq.transformers import GaugeTransformer, GaugeSelector, ConstantGauge
+
+
+class ExampleGate(cirq.testing.TwoQubitGate):
+    unitary = cirq.unitary(cirq.CZ**0.123)
+
+    def _unitary_(self) -> np.ndarray:
+        return self.unitary
+
+
+_EXAMPLE_TARGET = ExampleGate()
+
+_GOOD_TRANSFORMER = GaugeTransformer(
+    target=_EXAMPLE_TARGET,
+    gauge_selector=GaugeSelector(gauges=[ConstantGauge(two_qubit_gate=_EXAMPLE_TARGET)]),
+)
+
+_BAD_TRANSFORMER = GaugeTransformer(
+    target=_EXAMPLE_TARGET,
+    gauge_selector=GaugeSelector(
+        gauges=[ConstantGauge(two_qubit_gate=_EXAMPLE_TARGET, pre_q0=cirq.X)]
+    ),
+)
+
+
+class TestValidTransformer(GaugeTester):
+    two_qubit_gate = _EXAMPLE_TARGET
+    gauge_transformer = _GOOD_TRANSFORMER
+
+
+class TestInvalidTransformer(GaugeTester):
+    two_qubit_gate = _EXAMPLE_TARGET
+    gauge_transformer = _BAD_TRANSFORMER
+    must_fail = True

cirq/transformers/gauge_compiling/iswap_gauge.py

@@ -0,0 +1,105 @@
+# Copyright 2024 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.
+
+"""A Gauge transformer for ISWAP gate."""
+
+import numpy as np
+
+from cirq.transformers.gauge_compiling.gauge_compiling import (
+    ConstantGauge,
+    Gauge,
+    GaugeTransformer,
+    GaugeSelector,
+)
+from cirq import ops
+
+
+class RZRotation(Gauge):
+    """Represents an ISWAP Gauge composed of Rz rotations.
+
+    The gauge replaces an ISWAP gate with either
+        0: ───Rz(t)──────iSwap───Rz(sgn*t)───
+                            │
+        1: ───Rz(-sgn*t)───iSwap───Rz(-t)───
+
+    where t is uniformly sampled from [0, 2π) and sgn is uniformly sampled from {-1, 1}.
+    """
+
+    def weight(self) -> float:
+        return 2.0
+
+    def _rz(self, theta, sgn: int) -> ConstantGauge:
+        """Returns an ISWAP Gauge composed of Rz rotations.
+
+        0: ───Rz(theta)──────iSwap───Rz(sgn*theta)───
+                                │
+        1: ───Rz(-sgn*theta)───iSwap───Rz(-theta)───
+
+        """
+        flip_diangonal = sgn == -1
+        rz = ops.rz(theta)
+        n_rz = ops.rz(-theta)
+        return ConstantGauge(
+            two_qubit_gate=ops.ISWAP,
+            pre_q0=rz,
+            pre_q1=n_rz if flip_diangonal else rz,
+            post_q0=rz if flip_diangonal else n_rz,
+            post_q1=n_rz,
+        )
+
+    def sample(self, gate: ops.Gate, prng: np.random.Generator) -> ConstantGauge:
+        theta = prng.random() * 2 * np.pi
+        return self._rz(theta, prng.choice([-1, 1]))
+
+
+class XYRotation(Gauge):
+    """Represents an ISWAP Gauge composed of XY rotations.
+
+    The gauge replaces an ISWAP gate with either
+        0: ───XY(a)───iSwap───XY(b)───
+                        │
+        1: ───XY(b)───iSwap───XY(a)───
+
+    where a and b are uniformly sampled from [0, 2π) and XY is a single-qubit rotation defined as
+        XY(theta) = cos(theta) X + sin(theta) Y
+    """
+
+    def weight(self) -> float:
+        return 2.0
+
+    def _xy(self, theta: float) -> ops.PhasedXZGate:
+        unitary = np.cos(theta) * np.array([[0, 1], [1, 0]]) + np.sin(theta) * np.array(
+            [[0, -1j], [1j, 0]]
+        )
+        return ops.PhasedXZGate.from_matrix(unitary)
+
+    def _xy_gauge(self, a: float, b: float) -> ConstantGauge:
+        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
+        )
+
+    def sample(self, gate: ops.Gate, prng: np.random.Generator) -> ConstantGauge:
+        a = prng.random() * 2 * np.pi
+        if prng.choice([0, 1]):
+            return self._xy_gauge(a, a)
+        else:
+            b = prng.random() * 2 * np.pi
+            return self._xy_gauge(a, b)
+
+
+ISWAPGaugeTransformer = GaugeTransformer(
+    target=ops.ISWAP, gauge_selector=GaugeSelector(gauges=[RZRotation(), XYRotation()])
+)

cirq/transformers/gauge_compiling/iswap_gauge_test.py

@@ -0,0 +1,23 @@
+# Copyright 2024 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.
+
+
+import cirq
+from cirq.transformers.gauge_compiling import ISWAPGaugeTransformer
+from cirq.transformers.gauge_compiling.gauge_compiling_test_utils import GaugeTester
+
+
+class TestISWAPGauge(GaugeTester):
+    two_qubit_gate = cirq.ISWAP
+    gauge_transformer = ISWAPGaugeTransformer

cirq/transformers/gauge_compiling/spin_inversion_gauge.py

@@ -0,0 +1,33 @@
+# Copyright 2024 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.
+
+"""The spin inversion gauge transformer."""
+
+from cirq.transformers.gauge_compiling.gauge_compiling import (
+    GaugeTransformer,
+    GaugeSelector,
+    ConstantGauge,
+)
+from cirq import ops
+
+SpinInversionGaugeSelector = GaugeSelector(
+    gauges=[
+        ConstantGauge(two_qubit_gate=ops.ZZ, pre_q0=ops.X, post_q0=ops.X),
+        ConstantGauge(two_qubit_gate=ops.ZZ, pre_q1=ops.X, post_q1=ops.X),
+    ]
+)
+
+SpinInversionGaugeTransformer = GaugeTransformer(
+    target=ops.ZZ, gauge_selector=SpinInversionGaugeSelector
+)

cirq/transformers/gauge_compiling/spin_inversion_gauge_test.py

@@ -0,0 +1,23 @@
+# Copyright 2024 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.
+
+
+import cirq
+from cirq.transformers.gauge_compiling import SpinInversionGaugeTransformer
+from cirq.transformers.gauge_compiling.gauge_compiling_test_utils import GaugeTester
+
+
+class TestSpinInversionGauge(GaugeTester):
+    two_qubit_gate = cirq.ZZ
+    gauge_transformer = SpinInversionGaugeTransformer

cirq/transformers/gauge_compiling/sqrt_cz_gauge.py

@@ -0,0 +1,29 @@
+# Copyright 2024 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.
+
+"""A Gauge transformer for CZ**0.5 gate."""
+
+from cirq.transformers.gauge_compiling.gauge_compiling import (
+    GaugeTransformer,
+    GaugeSelector,
+    ConstantGauge,
+)
+from cirq.ops.common_gates import CZ
+from cirq import ops
+
+SqrtCZGaugeSelector = GaugeSelector(
+    gauges=[ConstantGauge(pre_q0=ops.X, post_q0=ops.X, post_q1=ops.Z**0.5, two_qubit_gate=CZ**-0.5)]
+)
+
+SqrtCZGaugeTransformer = GaugeTransformer(target=CZ**0.5, gauge_selector=SqrtCZGaugeSelector)

cirq/transformers/gauge_compiling/sqrt_cz_gauge_test.py

@@ -0,0 +1,23 @@
+# Copyright 2024 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.
+
+
+import cirq
+from cirq.transformers.gauge_compiling import SqrtCZGaugeTransformer
+from cirq.transformers.gauge_compiling.gauge_compiling_test_utils import GaugeTester
+
+
+class TestSqrtCZGauge(GaugeTester):
+    two_qubit_gate = cirq.CZ**0.5
+    gauge_transformer = SqrtCZGaugeTransformer

cirq/transformers/gauge_compiling/sqrt_iswap_gauge.py

@@ -0,0 +1,94 @@
+# Copyright 2024 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.
+
+"""A Gauge transformer for SQRT_ISWAP gate."""
+
+import numpy as np
+from cirq.transformers.gauge_compiling.gauge_compiling import (
+    ConstantGauge,
+    Gauge,
+    GaugeTransformer,
+    GaugeSelector,
+)
+from cirq import ops
+
+
+class RZRotation(Gauge):
+    """Represents a SQRT_ISWAP Gauge composed of Rz rotations.
+
+    The gauge replaces an SQRT_ISWAP gate with either
+        0: ───Rz(t)───iSwap───────Rz(-t)───
+                        │
+        1: ───Rz(t)───iSwap^0.5───Rz(-t)───
+
+    where t is uniformly sampled from [0, 2π).
+    """
+
+    def weight(self) -> float:
+        return 1.0
+
+    def _rz(self, theta: float) -> ConstantGauge:
+        """Returns a SQRT_ISWAP Gauge composed of Rz rotations.
+
+        0: ───Rz(theta)────iSwap───Rz(theta)───
+                            │
+        1: ───Rz(theta)───iSwap^0.5───Rz(theta)───
+
+        """
+        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
+        )
+
+    def sample(self, gate: ops.Gate, prng: np.random.Generator) -> ConstantGauge:
+        return self._rz(prng.random() * 2 * np.pi)
+
+
+class XYRotation(Gauge):
+    """Represents a SQRT_ISWAP Gauge composed of XY rotations.
+
+    The gauge replaces an SQRT_ISWAP gate with either
+        0: ───XY(t)───iSwap───────XY(t)───
+                        │
+        1: ───XY(t)───iSwap^0.5───XY(t)───
+
+    where t is uniformly sampled from [0, 2π) and
+        XY(theta) = cos(theta) X + sin(theta) Y
+    """
+
+    def weight(self) -> float:
+        return 1.0
+
+    def _xy(self, theta: float) -> ops.PhasedXZGate:
+        unitary = np.cos(theta) * np.array([[0, 1], [1, 0]]) + np.sin(theta) * np.array(
+            [[0, -1j], [1j, 0]]
+        )
+        return ops.PhasedXZGate.from_matrix(unitary)
+
+    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
+        )
+
+    def sample(self, gate: ops.Gate, prng: np.random.Generator) -> ConstantGauge:
+        return self._xy_gauge(prng.random() * 2 * np.pi)
+
+
+SqrtISWAPGaugeSelector = GaugeSelector(gauges=[RZRotation(), XYRotation()])
+
+SqrtISWAPGaugeTransformer = GaugeTransformer(
+    target=ops.SQRT_ISWAP, gauge_selector=SqrtISWAPGaugeSelector
+)

cirq/transformers/gauge_compiling/sqrt_iswap_gauge_test.py

@@ -0,0 +1,22 @@
+# Copyright 2024 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.
+
+import cirq
+from cirq.transformers.gauge_compiling import SqrtISWAPGaugeTransformer
+from cirq.transformers.gauge_compiling.gauge_compiling_test_utils import GaugeTester
+
+
+class TestSqrtISWAPGauge(GaugeTester):
+    two_qubit_gate = cirq.SQRT_ISWAP
+    gauge_transformer = SqrtISWAPGaugeTransformer

{cirq_core-1.4.0.dev20240402234712.dist-info → cirq_core-1.4.0.dev20240403011731.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cirq-core
-Version: 1.4.0.dev20240402234712
+Version: 1.4.0.dev20240403011731
 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
@@ -8,6 +8,7 @@ Author-email: cirq-dev@googlegroups.com
 License: Apache 2
 Requires-Python: >=3.9.0
 License-File: LICENSE
+Requires-Dist: attrs
 Requires-Dist: duet >=0.2.8
 Requires-Dist: matplotlib ~=3.0
 Requires-Dist: networkx >=2.4

{cirq_core-1.4.0.dev20240402234712.dist-info → cirq_core-1.4.0.dev20240403011731.dist-info}/RECORD

@@ -4,7 +4,7 @@ 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=uPithq0WLTaxyQeh8l3VzXZfCPZQcsVBh-fXeb6J7pM,40
+cirq/_version.py,sha256=8wUDndCJvT5IPWRPX7VzDqaJanKPlInnAFaWJF-lUJU,40
 cirq/_version_test.py,sha256=yYS6xm5-nuBRQJa9R3n41WdvFtVyY7Lb5Q8bea3VgBI,133
 cirq/conftest.py,sha256=X7yLFL8GLhg2CjPw0hp5e_dGASfvHx1-QT03aUbhKJw,1168
 cirq/json_resolver_cache.py,sha256=9g_JQMmfBzTuV-3s2flUbXIgcLjs4K7LjAFFgngdG1U,13204
@@ -909,7 +909,7 @@ cirq/sim/sparse_simulator_test.py,sha256=3EAeCHUQeKllAAtdw14X592zBsGQY_vwfIYK-gE
 cirq/sim/state_vector.py,sha256=N6N9EELlW66UaLTBaq62ms0XkfIK7CzN9SBM7t52dXo,13428
 cirq/sim/state_vector_simulation_state.py,sha256=e4it_DT1J-30S3OX_gfMJiWAttFaVOMEPQ-Y1ARWnDg,17616
 cirq/sim/state_vector_simulation_state_test.py,sha256=UtGMIurlV6N74nX7qoVnGoRhwF35-ghDEIP7Mj5AXmI,9841
-cirq/sim/state_vector_simulator.py,sha256=Q-wCmJdLIoJAssTvrZmGCpnooFHjZNXr_yeyy5R0NFs,7559
+cirq/sim/state_vector_simulator.py,sha256=M3k9VR7nht1gcovBjc3CaEoKbYIsCImAJyjS0_wb3ko,7942
 cirq/sim/state_vector_simulator_test.py,sha256=wJq1OZRzKokeM9cJyaJXi6wHH2qi97h0HmJlYOEBDzU,7864
 cirq/sim/state_vector_test.py,sha256=OjhAL2tWqJWstHV8RvJYQVqg95zm0PcS9nQKrLOhMmQ,16934
 cirq/sim/clifford/__init__.py,sha256=lD7l6JuE5n0xwvOYNYH-giCH3qAEVH1SUwDrZM1jKKY,636
@@ -1013,7 +1013,7 @@ cirq/testing/test_data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3
 cirq/testing/test_data/test_module_missing_json_test_data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cirq/testing/test_data/test_module_missing_testspec/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cirq/testing/test_data/test_module_missing_testspec/json_test_data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cirq/transformers/__init__.py,sha256=1nSFghZdxPq_PT8iuLPNLmfbkQcCaNAmC-RVSe9qzeg,3877
+cirq/transformers/__init__.py,sha256=Omi-8NLq9lMbMHV-eXxwrpX5_zw-ZyRJKPmIL_mIzMg,4145
 cirq/transformers/align.py,sha256=B4DuX84DWd4tLfMH21JviMZSOFYu7KCOMSEMALYsQpw,2727
 cirq/transformers/align_test.py,sha256=M4etT2cgESv1RdkKASguiGxEuqY7kmI1IswjSi-1jjY,7174
 cirq/transformers/drop_empty_moments.py,sha256=Rtn_BrpwkLXyZBdLzwdnsnEGWTdYuf1xOPakzbpv7-w,1517
@@ -1071,6 +1071,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=dmgVx7_yfsO9TarOCMBfVuZjza_6_MmUyAfM_eo698E,1146
+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=GCYpaZIUxkcz16s8DI64dtpHhSGiIy6JIplvM6GUklc,6662
+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/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=BMt1g2h23J9jb6LTlZsNczMKIY8J0duHhZNu0jRB48M,1107
+cirq/transformers/gauge_compiling/spin_inversion_gauge_test.py,sha256=PtbHNvh6Oz-n6Tn0fdvpgHGgaPuJQPlJ8UfHd59-dks,887
+cirq/transformers/gauge_compiling/sqrt_cz_gauge.py,sha256=l0Dkz2a7_ljKzzP-Rr9f_yY4pqJ8TGY_R-FVEkBb77I,1050
+cirq/transformers/gauge_compiling/sqrt_cz_gauge_test.py,sha256=wB_WezbTBbkwnTs7hz_tXmU4syuMulGirDDDjzqvNt0,871
+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=2KBAUk-vsVku-HuahLbDQxp8bjEQMZUUNiBz_cvUMUw,831
 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
@@ -1154,8 +1169,8 @@ cirq/work/sampler.py,sha256=JEAeQQRF3bqlO9AkOf4XbrTATDI5f5JgyM_FAUCNxao,19751
 cirq/work/sampler_test.py,sha256=B2ZsuqGT854gQtBIAh8k0LiG9Vj5wSzcGvkxOUoTcW4,13217
 cirq/work/zeros_sampler.py,sha256=x1C7cup66a43n-3tm8QjhiqJa07qcJW10FxNp9jJ59Q,2356
 cirq/work/zeros_sampler_test.py,sha256=JIkpBBFPJe5Ba4142vzogyWyboG1Q1ZAm0UVGgOoZn8,3279
-cirq_core-1.4.0.dev20240402234712.dist-info/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
-cirq_core-1.4.0.dev20240402234712.dist-info/METADATA,sha256=kUyv0z6F8Rp2LoUBXJZQZVAHKPjcZiAanosW5BawYfI,2078
-cirq_core-1.4.0.dev20240402234712.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-cirq_core-1.4.0.dev20240402234712.dist-info/top_level.txt,sha256=Sz9iOxHU0IEMLSFGwiwOCaN2e9K-jFbBbtpPN1hB73g,5
-cirq_core-1.4.0.dev20240402234712.dist-info/RECORD,,
+cirq_core-1.4.0.dev20240403011731.dist-info/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
+cirq_core-1.4.0.dev20240403011731.dist-info/METADATA,sha256=8nMDDTBH7qzIe21E0j2k4Hqzj4fYEk3Tmwh4Hc0qDGY,2099
+cirq_core-1.4.0.dev20240403011731.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+cirq_core-1.4.0.dev20240403011731.dist-info/top_level.txt,sha256=Sz9iOxHU0IEMLSFGwiwOCaN2e9K-jFbBbtpPN1hB73g,5
+cirq_core-1.4.0.dev20240403011731.dist-info/RECORD,,