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

cirq/transformers/eject_phased_paulis.py

@@ -14,11 +14,12 @@
 
 """Transformer pass that pushes 180° rotations around axes in the XY plane later in the circuit."""
 
-from typing import Optional, cast, TYPE_CHECKING, Iterable, Tuple, Dict
-import sympy
+from typing import cast, Dict, Iterable, Iterator, Optional, Tuple, TYPE_CHECKING, Union
+
 import numpy as np
+import sympy
 
-from cirq import circuits, ops, value, protocols
+from cirq import circuits, ops, protocols, value
 from cirq.transformers import transformer_api, transformer_primitives
 from cirq.transformers.analytical_decompositions import single_qubit_decompositions
 
@@ -62,7 +63,7 @@ def eject_phased_paulis(
     def map_func(op: 'cirq.Operation', _: int) -> 'cirq.OP_TREE':
         # Dump if `op` marked with a no compile tag.
         if set(op.tags) & tags_to_ignore:
-            return [_dump_held(op.qubits, held_w_phases), op]
+            return [_dump_held(op.qubits, held_w_phases, atol), op]
 
         # Collect, phase, and merge Ws.
         w = _try_get_known_phased_pauli(op, no_symbolic=not eject_parameterized)
@@ -70,7 +71,7 @@ def eject_phased_paulis(
             return (
                 _potential_cross_whole_w(op, atol, held_w_phases)
                 if single_qubit_decompositions.is_negligible_turn((w[0] - 1) / 2, atol)
-                else _potential_cross_partial_w(op, held_w_phases)
+                else _potential_cross_partial_w(op, held_w_phases, atol)
             )
 
         affected = [q for q in op.qubits if q in held_w_phases]
@@ -95,12 +96,12 @@ def eject_phased_paulis(
             )
 
         # Don't know how to handle this situation. Dump the gates.
-        return [_dump_held(op.qubits, held_w_phases), op]
+        return [_dump_held(op.qubits, held_w_phases, atol), op]
 
     # Map operations and put anything that's still held at the end of the circuit.
     return circuits.Circuit(
         transformer_primitives.map_operations_and_unroll(circuit, map_func),
-        _dump_held(held_w_phases.keys(), held_w_phases),
+        _dump_held(held_w_phases.keys(), held_w_phases, atol),
     )
 
 
@@ -126,14 +127,14 @@ def _absorb_z_into_w(
 
 
 def _dump_held(
-    qubits: Iterable[ops.Qid], held_w_phases: Dict[ops.Qid, value.TParamVal]
-) -> 'cirq.OP_TREE':
+    qubits: Iterable[ops.Qid], held_w_phases: Dict[ops.Qid, value.TParamVal], atol: float
+) -> Iterator['cirq.OP_TREE']:
     # Note: sorting is to avoid non-determinism in the insertion order.
     for q in sorted(qubits):
         p = held_w_phases.get(q)
         if p is not None:
-            dump_op = ops.PhasedXPowGate(phase_exponent=p).on(q)
-            yield dump_op
+            gate = _phased_x_or_pauli_gate(exponent=1.0, phase_exponent=p, atol=atol)
+            yield gate.on(q)
         held_w_phases.pop(q, None)
 
 
@@ -183,7 +184,7 @@ def _potential_cross_whole_w(
 
 
 def _potential_cross_partial_w(
-    op: ops.Operation, held_w_phases: Dict[ops.Qid, value.TParamVal]
+    op: ops.Operation, held_w_phases: Dict[ops.Qid, value.TParamVal], atol: float
 ) -> 'cirq.OP_TREE':
     """Cross the held W over a partial W gate.
 
@@ -203,10 +204,10 @@ def _potential_cross_partial_w(
     exponent, phase_exponent = cast(
         Tuple[value.TParamVal, value.TParamVal], _try_get_known_phased_pauli(op)
     )
-    new_op = ops.PhasedXPowGate(exponent=exponent, phase_exponent=2 * a - phase_exponent).on(
-        op.qubits[0]
+    gate = _phased_x_or_pauli_gate(
+        exponent=exponent, phase_exponent=2 * a - phase_exponent, atol=atol
     )
-    return new_op
+    return gate.on(op.qubits[0])
 
 
 def _single_cross_over_cz(op: ops.Operation, qubit_with_w: 'cirq.Qid') -> 'cirq.OP_TREE':
@@ -350,3 +351,16 @@ def _try_get_known_z_half_turns(
     if no_symbolic and isinstance(h, sympy.Basic):
         return None
     return h
+
+
+def _phased_x_or_pauli_gate(
+    exponent: Union[float, sympy.Expr], phase_exponent: Union[float, sympy.Expr], atol: float
+) -> Union['cirq.PhasedXPowGate', 'cirq.XPowGate', 'cirq.YPowGate']:
+    """Return PhasedXPowGate or X or Y gate if equivalent within atol in z-axis turns."""
+    if not isinstance(phase_exponent, sympy.Expr) or phase_exponent.is_constant():
+        half_turns = value.canonicalize_half_turns(float(phase_exponent))
+        if abs(half_turns / 2) <= atol:
+            return ops.XPowGate(exponent=exponent)
+        if abs((half_turns - 0.5) / 2) <= atol:
+            return ops.YPowGate(exponent=exponent)
+    return ops.PhasedXPowGate(exponent=exponent, phase_exponent=phase_exponent)

cirq/transformers/eject_phased_paulis_test.py

@@ -11,9 +11,9 @@
 # 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 dataclasses
 from typing import cast, Iterable
 
-import dataclasses
 import numpy as np
 import pytest
 import sympy
@@ -212,11 +212,7 @@ def test_crosses_czs():
             [cirq.CZ(a, b) ** 0.25],
         ),
         expected=quick_circuit(
-            [cirq.CZ(a, b) ** 0.25],
-            [
-                cirq.PhasedXPowGate(phase_exponent=0.5).on(b),
-                cirq.PhasedXPowGate(phase_exponent=0.25).on(a),
-            ],
+            [cirq.CZ(a, b) ** 0.25], [cirq.Y(b), cirq.PhasedXPowGate(phase_exponent=0.25).on(a)]
         ),
     )
     assert_optimizes(
@@ -387,8 +383,7 @@ def test_phases_partial_ws():
     assert_optimizes(
         before=quick_circuit([cirq.PhasedXPowGate(phase_exponent=0.25).on(q)], [cirq.X(q) ** 0.5]),
         expected=quick_circuit(
-            [cirq.PhasedXPowGate(phase_exponent=0.5, exponent=0.5).on(q)],
-            [cirq.PhasedXPowGate(phase_exponent=0.25).on(q)],
+            [cirq.Y(q) ** 0.5], [cirq.PhasedXPowGate(phase_exponent=0.25).on(q)]
         ),
     )
 

cirq/transformers/eject_z.py

@@ -14,8 +14,9 @@
 
 """Transformer pass that pushes Z gates later and later in the circuit."""
 
-from typing import Dict, Iterable, Optional, Tuple, TYPE_CHECKING
 from collections import defaultdict
+from typing import Dict, Iterable, Iterator, Optional, Tuple, TYPE_CHECKING
+
 import numpy as np
 
 from cirq import ops, protocols
@@ -76,7 +77,7 @@ def eject_z(
         lambda: None
     )
 
-    def dump_tracked_phase(qubits: Iterable[ops.Qid]) -> 'cirq.OP_TREE':
+    def dump_tracked_phase(qubits: Iterable[ops.Qid]) -> Iterator['cirq.OP_TREE']:
         """Zeroes qubit_phase entries by emitting Z gates."""
         for q in qubits:
             p, key = qubit_phase[q], last_phased_xz_op[q]

cirq/transformers/eject_z_test.py

@@ -14,8 +14,8 @@
 
 import dataclasses
 
-import pytest
 import numpy as np
+import pytest
 import sympy
 
 import cirq
@@ -51,10 +51,10 @@ def assert_optimizes(
         cirq.Moment(cirq.CircuitOperation(before.freeze()).repeat(3).with_tags("preserve_tag")),
     )
     c_expected = cirq.Circuit(
-        cirq.PhasedXPowGate(phase_exponent=0, exponent=0.25).on_each(*q),
+        (cirq.X**0.25).on_each(*q),
         (cirq.Z**0.5).on_each(*q),
         cirq.Moment(cirq.CircuitOperation(before.freeze()).repeat(2).with_tags("ignore")),
-        cirq.PhasedXPowGate(phase_exponent=0, exponent=0.25).on_each(*q),
+        (cirq.X**0.25).on_each(*q),
         (cirq.Z**0.5).on_each(*q),
         cirq.Moment(cirq.CircuitOperation(expected.freeze()).repeat(3).with_tags("preserve_tag")),
     )

cirq/transformers/gauge_compiling/__init__.py

@@ -14,13 +14,29 @@
 
 
 from cirq.transformers.gauge_compiling.gauge_compiling import (
-    ConstantGauge,
-    Gauge,
-    GaugeSelector,
-    GaugeTransformer,
+    ConstantGauge as ConstantGauge,
+    Gauge as Gauge,
+    GaugeSelector as GaugeSelector,
+    GaugeTransformer as GaugeTransformer,
+    TwoQubitGateSymbolizer as TwoQubitGateSymbolizer,
 )
-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
+
+from cirq.transformers.gauge_compiling.sqrt_cz_gauge import (
+    SqrtCZGaugeTransformer as SqrtCZGaugeTransformer,
+)
+
+from cirq.transformers.gauge_compiling.spin_inversion_gauge import (
+    SpinInversionGaugeTransformer as SpinInversionGaugeTransformer,
+)
+
+from cirq.transformers.gauge_compiling.cz_gauge import CZGaugeTransformer as CZGaugeTransformer
+
+from cirq.transformers.gauge_compiling.iswap_gauge import (
+    ISWAPGaugeTransformer as ISWAPGaugeTransformer,
+)
+
+from cirq.transformers.gauge_compiling.sqrt_iswap_gauge import (
+    SqrtISWAPGaugeTransformer as SqrtISWAPGaugeTransformer,
+)
+
+from cirq.transformers.gauge_compiling.cphase_gauge import CPhaseGaugeTransformer

cirq/transformers/gauge_compiling/cphase_gauge.py

@@ -0,0 +1,146 @@
+# Copyright 2025 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 cphase gate."""
+
+import numpy as np
+
+import cirq.transformers.gauge_compiling.sqrt_cz_gauge as sqrt_cz_gauge
+from cirq import ops
+from cirq.transformers.gauge_compiling.gauge_compiling import (
+    ConstantGauge,
+    Gauge,
+    GaugeSelector,
+    GaugeTransformer,
+    TwoQubitGateSymbolizer,
+)
+
+
+class CPhasePauliGauge(Gauge):
+    """Gauges for the cphase gate (CZPowGate).
+
+    We identify 16 distinct gauges, corresponding to the 16 two-qubit Pauli operators that can be
+    inserted before the cphase gate. When an anticommuting gate is inserted, the cphase angle is
+    negated (or equivalently, the exponent of the CZPowGate is negated), so both postive and
+    negative angles should be calibrated to use this.
+    """
+
+    def weight(self) -> float:
+        return 1.0
+
+    def _get_new_post(self, exponent: float, pre: ops.Gate) -> ops.Gate:
+        """Identify the new single-qubit gate that needs to be inserted in the case that both pre
+        gates are X or Y.
+
+        Args:
+            exponent: The exponent of the CZPowGate that is getting transformed.
+            pre: The gate (X or Y) that is inserted on a given qubit.
+
+        Returns:
+            The single-qubit gate to insert after the CZPowGate on the same qubit.
+
+        Raises:
+            ValueError: If pre is not X or Y.
+        """
+        if pre == ops.X:
+            return ops.PhasedXPowGate(exponent=1, phase_exponent=exponent / 2)
+        elif pre == ops.Y:
+            return ops.PhasedXZGate.from_zyz_exponents(z0=-exponent, y=1, z1=0)
+        else:
+            raise ValueError("pre should be cirq.X or cirq.Y")  # pragma: no cover
+
+    def _get_constant_gauge(
+        self, gate: ops.CZPowGate, pre_q0: ops.Gate, pre_q1: ops.Gate
+    ) -> ConstantGauge:
+        """Get the ConstantGauge corresponding to a given pre_q0 and pre_q1.
+
+        Args:
+            gate: The particular cphase gate to transform.
+            pre_q0: The Pauli (I, X, Y, or Z) to insert before the cphase gate on q0.
+            pre_q1: The Pauli (I, X, Y, or Z) to insert before the cphase gate on q1.
+
+        Returns:
+            The ConstantGauge implementing the given transformation.
+
+        Raises:
+            ValueError: If pre_q0 and pre_q1 are not both in {I, X, Y, Z}.
+        """
+
+        exponent = gate.exponent
+        commuting_paulis = {ops.I, ops.Z}
+        anticommuting_paulis = {ops.X, ops.Y}
+        if pre_q0 in commuting_paulis and pre_q1 in commuting_paulis:
+            return ConstantGauge(
+                two_qubit_gate=gate, pre_q0=pre_q0, pre_q1=pre_q1, post_q0=pre_q0, post_q1=pre_q1
+            )
+        elif pre_q0 in anticommuting_paulis and pre_q1 in commuting_paulis:
+            new_gate = ops.CZ ** (-exponent)
+            post_q1 = ops.Z ** (exponent) if pre_q1 == ops.I else ops.Z ** (1 + exponent)
+            return ConstantGauge(
+                two_qubit_gate=new_gate,
+                pre_q0=pre_q0,
+                pre_q1=pre_q1,
+                post_q0=pre_q0,
+                post_q1=post_q1,
+            )
+        elif pre_q0 in commuting_paulis and pre_q1 in anticommuting_paulis:
+            new_gate = ops.CZ ** (-exponent)
+            post_q0 = ops.Z ** (exponent) if pre_q0 == ops.I else ops.Z ** (1 + exponent)
+            return ConstantGauge(
+                two_qubit_gate=new_gate,
+                pre_q0=pre_q0,
+                pre_q1=pre_q1,
+                post_q0=post_q0,
+                post_q1=pre_q1,
+            )
+        elif pre_q0 in anticommuting_paulis and pre_q1 in anticommuting_paulis:
+            return ConstantGauge(
+                two_qubit_gate=gate,
+                pre_q0=pre_q0,
+                pre_q1=pre_q1,
+                post_q0=self._get_new_post(exponent, pre_q0),
+                post_q1=self._get_new_post(exponent, pre_q1),
+            )
+        else:
+            raise ValueError("pre_q0 and pre_q1 should be X, Y, Z, or I")  # pragma: no cover
+
+    def sample(self, gate: ops.Gate, prng: np.random.Generator) -> ConstantGauge:
+        """Sample the 16 cphase gauges at random.
+
+        Args:
+            gate: The CZPowGate to transform.
+            prng: The pseudorandom number generator.
+
+        Returns:
+            A ConstantGauge implementing the transformation.
+
+        Raises:
+            TypeError: if gate is not a CZPowGate
+        """
+
+        if not type(gate) == ops.CZPowGate:
+            raise TypeError("gate must be a CZPowGate")  # pragma: no cover
+        pre_q0, pre_q1 = prng.choice(np.array([ops.I, ops.X, ops.Y, ops.Z]), size=2, replace=True)
+        return self._get_constant_gauge(gate, pre_q0, pre_q1)
+
+
+CPhaseGaugeSelector = GaugeSelector(gauges=[CPhasePauliGauge()])
+
+CPhaseGaugeTransformer = GaugeTransformer(
+    target=ops.Gateset(ops.CZPowGate),
+    gauge_selector=CPhaseGaugeSelector,
+    two_qubit_gate_symbolizer=TwoQubitGateSymbolizer(
+        symbolizer_fn=sqrt_cz_gauge._symbolize_as_cz_pow, n_symbols=1
+    ),
+)

cirq/transformers/gauge_compiling/cphase_gauge_test.py

@@ -0,0 +1,42 @@
+# Copyright 2025 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.cphase_gauge import CPhaseGaugeTransformer
+from cirq.transformers.gauge_compiling.gauge_compiling_test_utils import GaugeTester
+
+
+class TestCPhaseGauge_0_3(GaugeTester):
+    two_qubit_gate = cirq.CZ**0.3
+    gauge_transformer = CPhaseGaugeTransformer
+
+
+class TestCPhaseGauge_m0_3(GaugeTester):
+    two_qubit_gate = cirq.CZ ** (-0.3)
+    gauge_transformer = CPhaseGaugeTransformer
+
+
+class TestCPhaseGauge_0_1(GaugeTester):
+    two_qubit_gate = cirq.CZ**0.1
+    gauge_transformer = CPhaseGaugeTransformer
+
+
+class TestCPhaseGauge_m0_1(GaugeTester):
+    two_qubit_gate = cirq.CZ ** (-0.1)
+    gauge_transformer = CPhaseGaugeTransformer
+
+
+class TestCPhaseGauge_0_7(GaugeTester):
+    two_qubit_gate = cirq.CZ**0.7
+    gauge_transformer = CPhaseGaugeTransformer

cirq/transformers/gauge_compiling/cz_gauge.py

@@ -14,13 +14,13 @@
 
 """A Gauge Transformer for the CZ gate."""
 
+from cirq import ops
+from cirq.ops.common_gates import CZ
 from cirq.transformers.gauge_compiling.gauge_compiling import (
-    GaugeTransformer,
-    GaugeSelector,
     ConstantGauge,
+    GaugeSelector,
+    GaugeTransformer,
 )
-from cirq.ops.common_gates import CZ
-from cirq import ops
 
 CZGaugeSelector = GaugeSelector(
     gauges=[