cirq-core 1.3.0.dev20231201164435__py3-none-any.whl → 1.4.0__py3-none-any.whl

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,
+    SameGateGauge,
+)
+from cirq import ops
+
+SpinInversionGaugeSelector = GaugeSelector(
+    gauges=[
+        SameGateGauge(pre_q0=ops.X, post_q0=ops.X, pre_q1=ops.X, post_q1=ops.X),
+        SameGateGauge(),
+    ]
+)
+
+SpinInversionGaugeTransformer = GaugeTransformer(
+    target=ops.GateFamily(ops.ZZPowGate), gauge_selector=SpinInversionGaugeSelector
+)

cirq/transformers/gauge_compiling/spin_inversion_gauge_test.py

@@ -0,0 +1,37 @@
+# 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_0(GaugeTester):
+    two_qubit_gate = cirq.ZZ
+    gauge_transformer = SpinInversionGaugeTransformer
+
+
+class TestSpinInversionGauge_1(GaugeTester):
+    two_qubit_gate = cirq.ZZ**0.1
+    gauge_transformer = SpinInversionGaugeTransformer
+
+
+class TestSpinInversionGauge_2(GaugeTester):
+    two_qubit_gate = cirq.ZZ**-1
+    gauge_transformer = SpinInversionGaugeTransformer
+
+
+class TestSpinInversionGauge_3(GaugeTester):
+    two_qubit_gate = cirq.ZZ**0.3
+    gauge_transformer = SpinInversionGaugeTransformer

cirq/transformers/gauge_compiling/sqrt_cz_gauge.py

@@ -0,0 +1,64 @@
+# 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 and CZ**-0.5 gates."""
+
+
+from typing import TYPE_CHECKING
+import numpy as np
+
+from cirq.transformers.gauge_compiling.gauge_compiling import (
+    GaugeTransformer,
+    GaugeSelector,
+    ConstantGauge,
+    Gauge,
+)
+from cirq.ops import CZ, S, X, Gateset
+
+if TYPE_CHECKING:
+    import cirq
+
+_SQRT_CZ = CZ**0.5
+_ADJ_S = S**-1
+
+
+class SqrtCZGauge(Gauge):
+
+    def weight(self) -> float:
+        return 3.0
+
+    def sample(self, gate: 'cirq.Gate', prng: np.random.Generator) -> ConstantGauge:
+        if prng.choice([True, False]):
+            return ConstantGauge(two_qubit_gate=gate)
+        swap_qubits = prng.choice([True, False])
+        if swap_qubits:
+            return ConstantGauge(
+                pre_q1=X,
+                post_q1=X,
+                post_q0=S if gate == _SQRT_CZ else _ADJ_S,
+                two_qubit_gate=gate**-1,
+                swap_qubits=True,
+            )
+        else:
+            return ConstantGauge(
+                pre_q0=X,
+                post_q0=X,
+                post_q1=S if gate == _SQRT_CZ else _ADJ_S,
+                two_qubit_gate=gate**-1,
+            )
+
+
+SqrtCZGaugeTransformer = GaugeTransformer(
+    target=Gateset(_SQRT_CZ, _SQRT_CZ**-1), gauge_selector=GaugeSelector(gauges=[SqrtCZGauge()])
+)

cirq/transformers/gauge_compiling/sqrt_cz_gauge_test.py

@@ -0,0 +1,27 @@
+# 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
+
+
+class TestAdjointSqrtCZGauge(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/transformers/heuristic_decompositions/two_qubit_gate_tabulation.py

@@ -55,6 +55,7 @@ class TwoQubitGateTabulationResult(NamedTuple):
             equal to U_target.
         success: Whether actual_gate is expected to be close to U_target.
     """
+
     base_gate_unitary: np.ndarray
     target_gate: np.ndarray
     local_unitaries: Tuple[_SingleQubitGatePair, ...]

cirq/transformers/merge_k_qubit_gates_test.py

@@ -122,13 +122,13 @@ def test_merge_complex_circuit_preserving_moment_structure():
     cirq.testing.assert_has_diagram(
         c_orig,
         '''
-0: ───H───@───@───H───@───X───────@─────────────────X───X['ignore']───@───X───
-          │   │       │           │                                   │   ║
-1: ───H───┼───X───────@───────Y───X───@['ignore']───────Y─────────────X───╫───
-          │                           │                                   ║
-2: ───H───X───────────────────────────X─────────────────Z─────────────M───╫───
-                                                                      ║   ║
-a: ═══════════════════════════════════════════════════════════════════@═══^═══
+0: ───H───@───@───H───@───X───────@───────────────X───X[ignore]───@───X───
+          │   │       │           │                               │   ║
+1: ───H───┼───X───────@───────Y───X───@[ignore]───────Y───────────X───╫───
+          │                           │                               ║
+2: ───H───X───────────────────────────X───────────────Z───────────M───╫───
+                                                                  ║   ║
+a: ═══════════════════════════════════════════════════════════════@═══^═══
 ''',
     )
     component_id = 0
@@ -147,15 +147,15 @@ a: ═════════════════════════
     cirq.testing.assert_has_diagram(
         cirq.drop_empty_moments(c_new),
         '''
-      [ 0: ───H───@─── ]        [ 0: ───────@───H───@───X───@───X─── ]                                            [ 0: ───────@─── ]
-0: ───[           │    ]────────[           │       │       │        ]──────────────────────X['ignore']───────────[           │    ]────────X───
-      [ 2: ───H───X─── ]['1']   [ 1: ───H───X───────@───Y───X─────── ]['2']                                       [ 1: ───Y───X─── ]['4']   ║
-      │                         │                                                                                 │                         ║
-1: ───┼─────────────────────────#2────────────────────────────────────────────@['ignore']─────────────────────────#2────────────────────────╫───
-      │                                                                       │                                                             ║
-2: ───#2──────────────────────────────────────────────────────────────────────X─────────────[ 2: ───Z─── ]['3']───M─────────────────────────╫───
-                                                                                                                  ║                         ║
-a: ═══════════════════════════════════════════════════════════════════════════════════════════════════════════════@═════════════════════════^═══''',
+      [ 0: ───H───@─── ]      [ 0: ───────@───H───@───X───@───X─── ]                                      [ 0: ───────@─── ]
+0: ───[           │    ]──────[           │       │       │        ]──────────────────X[ignore]───────────[           │    ]──────X───
+      [ 2: ───H───X─── ][1]   [ 1: ───H───X───────@───Y───X─────── ][2]                                   [ 1: ───Y───X─── ][4]   ║
+      │                       │                                                                           │                       ║
+1: ───┼───────────────────────#2──────────────────────────────────────────@[ignore]───────────────────────#2──────────────────────╫───
+      │                                                                   │                                                       ║
+2: ───#2──────────────────────────────────────────────────────────────────X───────────[ 2: ───Z─── ][3]───M───────────────────────╫───
+                                                                                                          ║                       ║
+a: ═══════════════════════════════════════════════════════════════════════════════════════════════════════@═══════════════════════^═══''',
     )
 
     component_id = 0
@@ -179,13 +179,13 @@ a: ═════════════════════════
     cirq.testing.assert_has_diagram(
         cirq.drop_empty_moments(c_new),
         '''
-0: ───T['1']───iSwap['1']───T['1']───T['2']───iSwap['2']───T['2']─────────────────X['ignore']───T['4']───iSwap['4']───T['4']───X───
-               │                              │                                                          │                     ║
-1: ────────────┼─────────────────────T['2']───iSwap^0.5────T['2']───@['ignore']─────────────────T['4']───iSwap^0.5────T['4']───╫───
-               │                                                    │                                                          ║
-2: ───T['1']───iSwap^0.5────T['1']──────────────────────────────────X─────────────T['3']────────M──────────────────────────────╫───
-                                                                                                ║                              ║
-a: ═════════════════════════════════════════════════════════════════════════════════════════════@══════════════════════════════^═══''',
+0: ───T[1]───iSwap[1]────T[1]───T[2]───iSwap[2]────T[2]───────────────X[ignore]───T[4]───iSwap[4]────T[4]───X───
+             │                         │                                                 │                  ║
+1: ──────────┼──────────────────T[2]───iSwap^0.5───T[2]───@[ignore]───────────────T[4]───iSwap^0.5───T[4]───╫───
+             │                                            │                                                 ║
+2: ───T[1]───iSwap^0.5───T[1]─────────────────────────────X───────────T[3]────────M─────────────────────────╫───
+                                                                                  ║                         ║
+a: ═══════════════════════════════════════════════════════════════════════════════@═════════════════════════^═══''',
     )
 
 

cirq/transformers/merge_single_qubit_gates_test.py

@@ -153,13 +153,13 @@ def test_merge_single_qubit_moments_to_phxz():
     cirq.testing.assert_has_diagram(
         c_orig,
         '''
-0: ───X───────Y───@───X───────Y───Y['nocompile']───X───M───────────
-                  │                                    ║
-1: ───X───T───Y───@───X───T───Y───Z────────────────────╫───X───X───
-                                                       ║   ║
-2: ───────T───────Y───────T───────Z────────────────────╫───╫───────
-                                                       ║   ║
-a: ════════════════════════════════════════════════════@═══^═══════
+0: ───X───────Y───@───X───────Y───Y[nocompile]───X───M───────────
+                  │                                  ║
+1: ───X───T───Y───@───X───T───Y───Z──────────────────╫───X───X───
+                                                     ║   ║
+2: ───────T───────Y───────T───────Z──────────────────╫───╫───────
+                                                     ║   ║
+a: ══════════════════════════════════════════════════@═══^═══════
 ''',
     )
     context = cirq.TransformerContext(tags_to_ignore=("nocompile",))
@@ -167,13 +167,13 @@ a: ═════════════════════════
     cirq.testing.assert_has_diagram(
         c_new,
         '''
-0: ───PhXZ(a=-0.5,x=0,z=-1)──────@───PhXZ(a=-0.5,x=0,z=-1)──────Y['nocompile']───X───M───────────
-                                 │                                                   ║
-1: ───PhXZ(a=-0.25,x=0,z=0.75)───@───PhXZ(a=-0.25,x=0,z=0.75)───Z────────────────────╫───X───X───
-                                                                                     ║   ║
-2: ───PhXZ(a=0.25,x=0,z=0.25)────Y───PhXZ(a=0.25,x=0,z=0.25)────Z────────────────────╫───╫───────
-                                                                                     ║   ║
-a: ══════════════════════════════════════════════════════════════════════════════════@═══^═══════
+0: ───PhXZ(a=-0.5,x=0,z=-1)──────@───PhXZ(a=-0.5,x=0,z=-1)──────Y[nocompile]───X───M───────────
+                                 │                                                 ║
+1: ───PhXZ(a=-0.25,x=0,z=0.75)───@───PhXZ(a=-0.25,x=0,z=0.75)───Z──────────────────╫───X───X───
+                                                                                   ║   ║
+2: ───PhXZ(a=0.25,x=0,z=0.25)────Y───PhXZ(a=0.25,x=0,z=0.25)────Z──────────────────╫───╫───────
+                                                                                   ║   ║
+a: ════════════════════════════════════════════════════════════════════════════════@═══^═══════
 ''',
     )