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

cirq/ops/parity_gates.py

@@ -14,24 +14,23 @@
 
 """Quantum gates that phase with respect to product-of-pauli observables."""
 
-from typing import Any, Dict, List, Optional, Tuple, Union, TYPE_CHECKING, Sequence
-from typing_extensions import Self
+from typing import Any, Dict, Iterator, List, Optional, Sequence, Tuple, TYPE_CHECKING, Union
 
 import numpy as np
+from typing_extensions import Self
 
 from cirq import protocols, value
 from cirq._compat import proper_repr
 from cirq._doc import document
 from cirq.ops import (
-    gate_features,
-    eigen_gate,
+    clifford_gate,
     common_gates,
+    eigen_gate,
+    gate_features,
     pauli_gates,
-    clifford_gate,
     pauli_interaction_gate,
 )
 
-
 if TYPE_CHECKING:
     import cirq
 
@@ -118,7 +117,7 @@ class XXPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate):
     def _has_stabilizer_effect_(self) -> bool:
         return self.exponent % 2 in (0, 0.5, 1, 1.5)
 
-    def _decompose_(self, qubits: Tuple['cirq.Qid', ...]) -> 'cirq.OP_TREE':
+    def _decompose_(self, qubits: Tuple['cirq.Qid', ...]) -> Iterator['cirq.OP_TREE']:
         yield common_gates.YPowGate(exponent=-0.5).on_each(*qubits)
         yield ZZPowGate(exponent=self.exponent, global_shift=self.global_shift)(*qubits)
         yield common_gates.YPowGate(exponent=0.5).on_each(*qubits)
@@ -227,7 +226,7 @@ class YYPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate):
     def _has_stabilizer_effect_(self) -> bool:
         return self.exponent % 2 in (0, 0.5, 1, 1.5)
 
-    def _decompose_(self, qubits: Tuple['cirq.Qid', ...]) -> 'cirq.OP_TREE':
+    def _decompose_(self, qubits: Tuple['cirq.Qid', ...]) -> Iterator['cirq.OP_TREE']:
         yield common_gates.XPowGate(exponent=0.5).on_each(*qubits)
         yield ZZPowGate(exponent=self.exponent, global_shift=self.global_shift)(*qubits)
         yield common_gates.XPowGate(exponent=-0.5).on_each(*qubits)

cirq/ops/parity_gates_test.py

@@ -39,6 +39,7 @@ def test_xx_eq():
         cirq.XXPowGate(),
         cirq.XXPowGate(exponent=1, global_shift=0),
         cirq.XXPowGate(exponent=3, global_shift=0),
+        cirq.XXPowGate(global_shift=100000),
     )
     eq.add_equality_group(cirq.XX**0.5, cirq.XX**2.5, cirq.XX**4.5)
     eq.add_equality_group(cirq.XX**0.25, cirq.XX**2.25, cirq.XX**-1.75)

cirq/ops/pauli_gates.py

@@ -12,22 +12,21 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 import abc
-from typing import Any, cast, Tuple, TYPE_CHECKING, Union, Dict
+from types import NotImplementedType
+from typing import Any, cast, Dict, Tuple, TYPE_CHECKING, Union
 
 from cirq._doc import document
 from cirq._import import LazyLoader
-from cirq.ops import common_gates, raw_types, identity
-from cirq.type_workarounds import NotImplementedType
-
+from cirq.ops import common_gates, identity, raw_types
 
 if TYPE_CHECKING:
     import cirq
     from cirq.ops.pauli_string import SingleQubitPauliStringGateOperation
-    from cirq.value.product_state import (
+    from cirq.value.product_state import (  # pragma: no cover
         _XEigenState,
         _YEigenState,
         _ZEigenState,
-    )  # pragma: no cover
+    )
 
 
 pauli_string = LazyLoader("pauli_string", globals(), "cirq.ops.pauli_string")
@@ -104,11 +103,6 @@ class Pauli(raw_types.Gate, metaclass=abc.ABCMeta):
 
         return pauli_string.SingleQubitPauliStringGateOperation(self, qubits[0])
 
-    @property
-    def _canonical_exponent(self):
-        """Overrides EigenGate._canonical_exponent in subclasses."""
-        return 1
-
 
 class _PauliX(Pauli, common_gates.XPowGate):
     def __init__(self):

cirq/ops/pauli_gates_test.py

@@ -16,6 +16,7 @@ import itertools
 
 import numpy as np
 import pytest
+
 import cirq
 
 

cirq/ops/pauli_interaction_gate.py

@@ -12,13 +12,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Any, Dict, List, Sequence, TYPE_CHECKING, Tuple
+from typing import Any, Dict, Iterator, List, Sequence, Tuple, TYPE_CHECKING
 
 import numpy as np
 
-from cirq import value, protocols
+from cirq import protocols, value
 from cirq._compat import proper_repr
-from cirq.ops import gate_features, common_gates, eigen_gate, pauli_gates
+from cirq.ops import common_gates, eigen_gate, gate_features, pauli_gates
 from cirq.ops.clifford_gate import SingleQubitCliffordGate
 
 if TYPE_CHECKING:
@@ -85,7 +85,13 @@ class PauliInteractionGate(gate_features.InterchangeableQubitsGate, eigen_gate.E
         return 2
 
     def _value_equality_values_(self):
-        return (self.pauli0, self.invert0, self.pauli1, self.invert1, self._canonical_exponent)
+        return (
+            self.pauli0,
+            self.invert0,
+            self.pauli1,
+            self.invert1,
+            value.PeriodicValue(self.exponent, 2),
+        )
 
     def qubit_index_to_equivalence_group_key(self, index: int) -> int:
         if self.pauli0 == self.pauli1 and self.invert0 == self.invert1:
@@ -108,7 +114,7 @@ class PauliInteractionGate(gate_features.InterchangeableQubitsGate, eigen_gate.E
         comp0 = np.eye(4) - comp1
         return [(0, comp0), (1, comp1)]
 
-    def _decompose_(self, qubits: Sequence['cirq.Qid']) -> 'cirq.OP_TREE':
+    def _decompose_(self, qubits: Sequence['cirq.Qid']) -> Iterator['cirq.OP_TREE']:
         q0, q1 = qubits
         right_gate0 = SingleQubitCliffordGate.from_single_map(z_to=(self.pauli0, self.invert0))
         right_gate1 = SingleQubitCliffordGate.from_single_map(z_to=(self.pauli1, self.invert1))

cirq/ops/pauli_interaction_gate_test.py

@@ -13,14 +13,13 @@
 # limitations under the License.
 
 import itertools
-import pytest
+
 import numpy as np
+import pytest
 import sympy
 
-
 import cirq
 
-
 _bools = (False, True)
 _paulis = (cirq.X, cirq.Y, cirq.Z)
 

cirq/ops/pauli_measurement_gate.py

@@ -14,25 +14,26 @@
 
 from typing import (
     Any,
+    cast,
     Dict,
     FrozenSet,
     Iterable,
+    Iterator,
     Mapping,
-    Tuple,
     Sequence,
+    Tuple,
     TYPE_CHECKING,
     Union,
-    cast,
 )
 
 from cirq import protocols, value
 from cirq.ops import (
-    raw_types,
+    dense_pauli_string as dps,
     measurement_gate,
     op_tree,
-    dense_pauli_string as dps,
     pauli_gates,
     pauli_string_phasor,
+    raw_types,
 )
 
 if TYPE_CHECKING:
@@ -144,7 +145,7 @@ class PauliMeasurementGate(raw_types.Gate):
 
     def _decompose_(
         self, qubits: Tuple['cirq.Qid', ...]
-    ) -> 'protocols.decompose_protocol.DecomposeResult':
+    ) -> Iterator['protocols.decompose_protocol.DecomposeResult']:
         any_qubit = qubits[0]
         to_z_ops = op_tree.freeze_op_tree(self._observable.on(*qubits).to_z_basis_ops())
         xor_decomp = tuple(pauli_string_phasor.xor_nonlocal_decompose(qubits, any_qubit))

cirq/ops/pauli_measurement_gate_test.py

@@ -63,6 +63,7 @@ def test_measurement_eq():
     [
         (None, None, 'b'),
         (cirq.with_key_path, ('p', 'q'), 'p:q:a'),
+        (cirq.with_key_path_prefix, ('p', 'q'), 'p:q:a'),
         (cirq.with_measurement_key_mapping, {'a': 'b'}, 'b'),
     ],
 )

cirq/ops/pauli_string.py

@@ -14,10 +14,14 @@
 import cmath
 import math
 import numbers
+from types import NotImplementedType
 from typing import (
+    AbstractSet,
     Any,
+    Callable,
     cast,
     Dict,
+    Generic,
     ItemsView,
     Iterable,
     Iterator,
@@ -27,27 +31,23 @@ from typing import (
     Optional,
     overload,
     Sequence,
-    SupportsComplex,
     Tuple,
     TYPE_CHECKING,
     TypeVar,
     Union,
     ValuesView,
-    AbstractSet,
-    Callable,
-    Generic,
 )
 
 import numpy as np
 import sympy
 
-import cirq
-from cirq import value, protocols, linalg, qis, _compat
+from cirq import _compat, linalg, protocols, qis, value
 from cirq._doc import document
 from cirq._import import LazyLoader
 from cirq.ops import (
     clifford_gate,
     common_gates,
+    dense_pauli_string,
     gate_operation,
     global_phase_op,
     identity,
@@ -56,7 +56,6 @@ from cirq.ops import (
     pauli_interaction_gate,
     raw_types,
 )
-from cirq.type_workarounds import NotImplementedType
 
 if TYPE_CHECKING:
     import cirq
@@ -271,9 +270,7 @@ class PauliString(raw_types.Operation, Generic[TKey]):
         pass
 
     @overload
-    def __mul__(
-        self, other: Union[complex, int, float, numbers.Number]
-    ) -> 'cirq.PauliString[TKey]':
+    def __mul__(self, other: complex) -> 'cirq.PauliString[TKey]':
         pass
 
     def __mul__(self, other):
@@ -308,23 +305,21 @@ class PauliString(raw_types.Operation, Generic[TKey]):
         )
 
     def __rmul__(self, other) -> 'PauliString':
-        if isinstance(other, numbers.Number):
+        if isinstance(other, numbers.Complex):
             return PauliString(
-                qubit_pauli_map=self._qubit_pauli_map,
-                coefficient=self._coefficient * complex(cast(SupportsComplex, other)),
+                qubit_pauli_map=self._qubit_pauli_map, coefficient=self._coefficient * other
             )
 
         if isinstance(other, raw_types.Operation) and isinstance(other.gate, identity.IdentityGate):
-            return self
+            return self  # pragma: no cover
 
         # Note: PauliString case handled by __mul__.
         return NotImplemented
 
     def __truediv__(self, other):
-        if isinstance(other, numbers.Number):
+        if isinstance(other, numbers.Complex):
             return PauliString(
-                qubit_pauli_map=self._qubit_pauli_map,
-                coefficient=self._coefficient / complex(cast(SupportsComplex, other)),
+                qubit_pauli_map=self._qubit_pauli_map, coefficient=self._coefficient / other
             )
         return NotImplemented
 
@@ -467,7 +462,7 @@ class PauliString(raw_types.Operation, Generic[TKey]):
         fused = prefix + '*'.join(factors)
         if len(factors) > 1:
             return f'({fused})'
-        return fused
+        return fused  # pragma: no cover
 
     def __str__(self) -> str:
         ordered_qubits = sorted(self.qubits)
@@ -500,7 +495,7 @@ class PauliString(raw_types.Operation, Generic[TKey]):
         """
         qubits = self.qubits if qubits is None else qubits
         factors = [self.get(q, default=identity.I) for q in qubits]
-        if cirq.is_parameterized(self):
+        if protocols.is_parameterized(self):
             raise NotImplementedError('Cannot express as matrix when parameterized')
         assert isinstance(self.coefficient, complex)
         return linalg.kron(self.coefficient, *[protocols.unitary(f) for f in factors])
@@ -518,7 +513,7 @@ class PauliString(raw_types.Operation, Generic[TKey]):
     def _apply_unitary_(self, args: 'protocols.ApplyUnitaryArgs'):
         if not self._has_unitary_():
             return None
-        assert isinstance(self.coefficient, complex)
+        assert isinstance(self.coefficient, numbers.Complex)
         if self.coefficient != 1:
             args.target_tensor *= self.coefficient
         return protocols.apply_unitaries([self[q].on(q) for q in self.qubits], self.qubits, args)
@@ -792,9 +787,11 @@ class PauliString(raw_types.Operation, Generic[TKey]):
         return self
 
     def __array_ufunc__(self, ufunc, method, *inputs, **kwargs):
-        """Override behavior of numpy's exp method."""
+        """Override numpy behavior."""
         if ufunc == np.exp and len(inputs) == 1 and inputs[0] is self:
             return math.e**self
+        if ufunc == np.multiply and len(inputs) == 2 and inputs[1] is self:
+            return self * inputs[0]
         return NotImplemented
 
     def __pow__(self, power):
@@ -910,14 +907,13 @@ class PauliString(raw_types.Operation, Generic[TKey]):
         Raises:
             ValueError: If the number of qubits is too small.
         """
-        from cirq.ops.dense_pauli_string import DensePauliString
 
         if not self.keys() <= set(qubits):
             raise ValueError('not self.keys() <= set(qubits)')
         # pylint: disable=too-many-function-args
         pauli_mask = [self.get(q, identity.I) for q in qubits]
         # pylint: enable=too-many-function-args
-        return DensePauliString(pauli_mask, coefficient=self.coefficient)
+        return dense_pauli_string.DensePauliString(pauli_mask, coefficient=self.coefficient)
 
     def conjugated_by(self, clifford: 'cirq.OP_TREE') -> 'PauliString':
         r"""Returns the Pauli string conjugated by a clifford operation.
@@ -979,17 +975,65 @@ class PauliString(raw_types.Operation, Generic[TKey]):
         Returns:
             The Pauli string conjugated by the given Clifford operation.
         """
-        pauli_map = dict(self._qubit_pauli_map)
-        should_negate = False
-        for op in list(op_tree.flatten_to_ops(clifford))[::-1]:
-            if pauli_map.keys().isdisjoint(set(op.qubits)):
-                continue
-            for clifford_op in _decompose_into_cliffords(op)[::-1]:
-                if pauli_map.keys().isdisjoint(set(clifford_op.qubits)):
-                    continue
-                should_negate ^= _pass_operation_over(pauli_map, clifford_op, False)
-        coef = -self._coefficient if should_negate else self.coefficient
-        return PauliString(qubit_pauli_map=pauli_map, coefficient=coef)
+
+        # Initialize the ps the same as self.
+        ps = PauliString(qubit_pauli_map=self._qubit_pauli_map, coefficient=self.coefficient)
+        all_ops = list(op_tree.flatten_to_ops(clifford))
+        all_qubits = set.union(set(self.qubits), [q for op in all_ops for q in op.qubits])
+        # Iteratively calculate the conjugation in reverse order of ops.
+        for op in all_ops[::-1]:
+            # To calcuate the conjugation of P (`ps`) with respect to C (`op`)
+            # Decompose P = Pc⊗R, where Pc acts on the same qubits as C, R acts on the remaining.
+            # Then the conjugation = (C^{-1}⊗I·Pc⊗R·C⊗I) = (C^{-1}·Pc·C)⊗R.
+
+            # Isolate R
+            remain: 'cirq.PauliString' = PauliString(
+                *(pauli(q) for q in all_qubits - set(op.qubits) if (pauli := ps.get(q)) is not None)
+            )
+
+            # Initialize the conjugation of Pc.
+            conjugated: 'cirq.DensePauliString' = (
+                dense_pauli_string.DensePauliString(pauli_mask=[identity.I for _ in op.qubits])
+                * ps.coefficient
+            )
+
+            # Calculate the conjugation via CliffordGate's clifford_tableau.
+            # Note the clifford_tableau in CliffordGate represents C·P·C^-1 instead of C^-1·P·C.
+            # So we take the inverse of the tableau to match the definition of the conjugation here.
+            gate_in_clifford: 'cirq.CliffordGate'
+            if isinstance(op.gate, clifford_gate.CliffordGate):
+                gate_in_clifford = op.gate
+            else:
+                # Convert the clifford gate to CliffordGate type.
+                gate_in_clifford = clifford_gate.CliffordGate.from_op_list([op], op.qubits)
+            tableau = gate_in_clifford.clifford_tableau.inverse()
+
+            # Calculate the conjugation by `op` via mutiplying the conjugation of each Pauli:
+            #   C^{-1}·(P_1⊗...⊗P_n)·C
+            # = C^{-1}·(P_1⊗I) ...·(P_n⊗I)·C
+            # = (C^{-1}(P_1⊗I)C)·...·(C^{-1}(P_n⊗I)C)
+            # For the Pauli on the kth qubit P_k. The conjugation is calculated as following.
+            #   Puali X_k's conjugation is from the destabilzer table;
+            #   Puali Z_k's conjugation is from the stabilzer table;
+            #   Puali Y_k's conjugation is calcluated according to Y = iXZ. E.g., for the kth qubit,
+            #     C^{-1}·Y_k⊗I·C = C^{-1}·(iX_k⊗I·Z_k⊗I)·C = i (C^{-1}·X_k⊗I·C)·(C^{-1}·Z_k⊗I·C).
+            for qid, qubit in enumerate(op.qubits):
+                pauli = ps.get(qubit)
+                match pauli:
+                    case None:
+                        continue
+                    case pauli_gates.X:
+                        conjugated *= tableau.destabilizers()[qid]
+                    case pauli_gates.Z:
+                        conjugated *= tableau.stabilizers()[qid]
+                    case pauli_gates.Y:
+                        conjugated *= (
+                            1j
+                            * tableau.destabilizers()[qid]  # conj X first
+                            * tableau.stabilizers()[qid]  # then conj Z
+                        )
+            ps = remain * conjugated.on(*op.qubits)
+        return ps
 
     def after(self, ops: 'cirq.OP_TREE') -> 'cirq.PauliString':
         r"""Determines the equivalent pauli string after some operations.
@@ -1052,20 +1096,17 @@ class PauliString(raw_types.Operation, Generic[TKey]):
                 pauli string, instead of before (and so are moving in the
                 opposite direction).
         """
-        pauli_map = dict(self._qubit_pauli_map)
-        should_negate = False
-        for op in ops:
-            if pauli_map.keys().isdisjoint(set(op.qubits)):
-                continue
-            decomposed = _decompose_into_cliffords(op)
-            if not after_to_before:
-                decomposed = decomposed[::-1]
-            for clifford_op in decomposed:
-                if pauli_map.keys().isdisjoint(set(clifford_op.qubits)):
-                    continue
-                should_negate ^= _pass_operation_over(pauli_map, clifford_op, after_to_before)
-        coef = -self._coefficient if should_negate else self.coefficient
-        return PauliString(qubit_pauli_map=pauli_map, coefficient=coef)
+        # TODO(#6946): deprecate this method.
+        # Note: This method is supposed to be replaced by conjugated_by()
+        #  (see #2351 for details).
+        if after_to_before:
+            return self.after(ops)
+
+        if isinstance(ops, gate_operation.GateOperation):
+            return self.before(ops)
+
+        all_ops = list(op_tree.flatten_to_ops(ops))
+        return self.before(all_ops[::-1])
 
     def _is_parameterized_(self) -> bool:
         return protocols.is_parameterized(self.coefficient)
@@ -1120,6 +1161,23 @@ def _validate_qubit_mapping(
         )
 
 
+def _try_interpret_as_pauli_string(op: Any):
+    """Return a reprepresentation of an operation as a pauli string, if it is possible."""
+    if isinstance(op, gate_operation.GateOperation):
+        gates = {
+            common_gates.XPowGate: pauli_gates.X,
+            common_gates.YPowGate: pauli_gates.Y,
+            common_gates.ZPowGate: pauli_gates.Z,
+        }
+        if (pauli := gates.get(type(op.gate), None)) is not None:
+            exponent = op.gate.exponent  # type: ignore
+            if exponent % 2 == 0:
+                return PauliString()
+            if exponent % 2 == 1:
+                return pauli.on(op.qubits[0])
+    return None
+
+
 # Ignoring type because mypy believes `with_qubits` methods are incompatible.
 class SingleQubitPauliStringGateOperation(  # type: ignore
     gate_operation.GateOperation, PauliString
@@ -1157,13 +1215,17 @@ class SingleQubitPauliStringGateOperation(  # type: ignore
     def __mul__(self, other):
         if isinstance(other, SingleQubitPauliStringGateOperation):
             return self._as_pauli_string() * other._as_pauli_string()
-        if isinstance(other, (PauliString, complex, float, int)):
+        if isinstance(other, (PauliString, numbers.Complex)):
             return self._as_pauli_string() * other
+        if (as_pauli_string := _try_interpret_as_pauli_string(other)) is not None:
+            return self * as_pauli_string
         return NotImplemented
 
     def __rmul__(self, other):
-        if isinstance(other, (PauliString, complex, float, int)):
+        if isinstance(other, (PauliString, numbers.Complex)):
             return other * self._as_pauli_string()
+        if (as_pauli_string := _try_interpret_as_pauli_string(other)) is not None:
+            return as_pauli_string * self
         return NotImplemented
 
     def __neg__(self):
@@ -1409,8 +1471,8 @@ class MutablePauliString(Generic[TKey]):
                 pauli_int = _pauli_like_to_pauli_int(qubit, pauli_gate_like)
                 phase_log_i += self._imul_atom_helper(cast(TKey, qubit), pauli_int, sign)
             self.coefficient *= 1j ** (phase_log_i & 3)
-        elif isinstance(other, numbers.Number):
-            self.coefficient *= complex(cast(SupportsComplex, other))
+        elif isinstance(other, numbers.Complex):
+            self.coefficient *= other
         elif isinstance(other, raw_types.Operation) and isinstance(
             other.gate, identity.IdentityGate
         ):
@@ -1584,88 +1646,11 @@ def _decompose_into_cliffords(op: 'cirq.Operation') -> List['cirq.Operation']:
     if decomposed is not None:
         return [out for sub_op in decomposed for out in _decompose_into_cliffords(sub_op)]
 
-    raise TypeError(
+    raise TypeError(  # pragma: no cover
         f'Operation is not a known Clifford and did not decompose into known Cliffords: {op!r}'
     )
 
 
-def _pass_operation_over(
-    pauli_map: Dict[TKey, pauli_gates.Pauli], op: 'cirq.Operation', after_to_before: bool = False
-) -> bool:
-    if isinstance(op, gate_operation.GateOperation):
-        gate = op.gate
-        if isinstance(gate, clifford_gate.SingleQubitCliffordGate):
-            return _pass_single_clifford_gate_over(
-                pauli_map, gate, cast(TKey, op.qubits[0]), after_to_before=after_to_before
-            )
-        if isinstance(gate, pauli_interaction_gate.PauliInteractionGate):
-            return _pass_pauli_interaction_gate_over(
-                pauli_map,
-                gate,
-                cast(TKey, op.qubits[0]),
-                cast(TKey, op.qubits[1]),
-                after_to_before=after_to_before,
-            )
-    raise NotImplementedError(f'Unsupported operation: {op!r}')
-
-
-def _pass_single_clifford_gate_over(
-    pauli_map: Dict[TKey, pauli_gates.Pauli],
-    gate: clifford_gate.SingleQubitCliffordGate,
-    qubit: TKey,
-    after_to_before: bool = False,
-) -> bool:
-    if qubit not in pauli_map:
-        return False  # pragma: no cover
-    if not after_to_before:
-        gate **= -1
-    pauli, inv = gate.pauli_tuple(pauli_map[qubit])
-    pauli_map[qubit] = pauli
-    return inv
-
-
-def _pass_pauli_interaction_gate_over(
-    pauli_map: Dict[TKey, pauli_gates.Pauli],
-    gate: pauli_interaction_gate.PauliInteractionGate,
-    qubit0: TKey,
-    qubit1: TKey,
-    after_to_before: bool = False,
-) -> bool:
-    def merge_and_kickback(
-        qubit: TKey,
-        pauli_left: Optional[pauli_gates.Pauli],
-        pauli_right: Optional[pauli_gates.Pauli],
-        inv: bool,
-    ) -> int:
-        assert pauli_left is not None or pauli_right is not None
-        if pauli_left is None or pauli_right is None:
-            pauli_map[qubit] = cast(pauli_gates.Pauli, pauli_left or pauli_right)
-            return 0
-        if pauli_left == pauli_right:
-            del pauli_map[qubit]
-            return 0
-
-        pauli_map[qubit] = pauli_left.third(pauli_right)
-        if (pauli_left < pauli_right) ^ after_to_before:
-            return int(inv) * 2 + 1
-
-        return int(inv) * 2 - 1
-
-    quarter_kickback = 0
-    if qubit0 in pauli_map and not protocols.commutes(pauli_map[qubit0], gate.pauli0):
-        quarter_kickback += merge_and_kickback(
-            qubit1, gate.pauli1, pauli_map.get(qubit1), gate.invert1
-        )
-    if qubit1 in pauli_map and not protocols.commutes(pauli_map[qubit1], gate.pauli1):
-        quarter_kickback += merge_and_kickback(
-            qubit0, pauli_map.get(qubit0), gate.pauli0, gate.invert0
-        )
-    assert (
-        quarter_kickback % 2 == 0
-    ), 'Impossible condition.  quarter_kickback is either incremented twice or never.'
-    return quarter_kickback % 4 == 2
-
-
 # Mypy has extreme difficulty with these constants for some reason.
 _i = cast(identity.IdentityGate, identity.I)  # type: ignore
 _x = cast(pauli_gates.Pauli, pauli_gates.X)  # type: ignore