cirq-core 1.5.0.dev20250409222543__py3-none-any.whl → 1.6.0__py3-none-any.whl

cirq/ops/pauli_string_phasor.py

@@ -12,23 +12,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import numbers
-from typing import (
-    AbstractSet,
-    cast,
-    Dict,
-    Iterable,
-    Iterator,
-    Optional,
-    Sequence,
-    TYPE_CHECKING,
-    Union,
-)
+from __future__ import annotations
 
-import sympy
+import numbers
+from typing import AbstractSet, cast, Iterable, Iterator, Sequence, TYPE_CHECKING
 
 from cirq import protocols, value
-from cirq._compat import proper_repr
+from cirq._compat import deprecated, proper_repr
 from cirq.ops import (
     common_gates,
     dense_pauli_string as dps,
@@ -40,6 +30,8 @@ from cirq.ops import (
 )
 
 if TYPE_CHECKING:
+    import sympy
+
     import cirq
 
 
@@ -63,10 +55,10 @@ class PauliStringPhasor(gate_operation.GateOperation):
     def __init__(
         self,
         pauli_string: ps.PauliString,
-        qubits: Optional[Sequence['cirq.Qid']] = None,
+        qubits: Sequence[cirq.Qid] | None = None,
         *,
-        exponent_neg: 'cirq.TParamVal' = 1,
-        exponent_pos: 'cirq.TParamVal' = 0,
+        exponent_neg: cirq.TParamVal = 1,
+        exponent_pos: cirq.TParamVal = 0,
     ) -> None:
         """Initializes the operation.
 
@@ -106,34 +98,34 @@ class PauliStringPhasor(gate_operation.GateOperation):
         self._pauli_string = gate.dense_pauli_string.on(*self.qubits)
 
     @property
-    def gate(self) -> 'cirq.PauliStringPhasorGate':
+    def gate(self) -> cirq.PauliStringPhasorGate:
         """The gate applied by the operation."""
         return cast(PauliStringPhasorGate, self._gate)
 
     @property
-    def exponent_neg(self) -> 'cirq.TParamVal':
+    def exponent_neg(self) -> cirq.TParamVal:
         """The negative exponent."""
         return self.gate.exponent_neg
 
     @property
-    def exponent_pos(self) -> 'cirq.TParamVal':
+    def exponent_pos(self) -> cirq.TParamVal:
         """The positive exponent."""
         return self.gate.exponent_pos
 
     @property
-    def pauli_string(self) -> 'cirq.PauliString':
+    def pauli_string(self) -> cirq.PauliString:
         """The underlying pauli string."""
         return self._pauli_string
 
     @property
-    def exponent_relative(self) -> 'cirq.TParamVal':
+    def exponent_relative(self) -> cirq.TParamVal:
         """The relative exponent between negative and positive exponents."""
         return self.gate.exponent_relative
 
     def _value_equality_values_(self):
         return (self.pauli_string, self.qubits, self.exponent_neg, self.exponent_pos)
 
-    def equal_up_to_global_phase(self, other: 'PauliStringPhasor') -> bool:
+    def equal_up_to_global_phase(self, other: PauliStringPhasor) -> bool:
         """Checks equality of two PauliStringPhasors, up to global phase."""
         if isinstance(other, PauliStringPhasor):
             return (
@@ -143,7 +135,7 @@ class PauliStringPhasor(gate_operation.GateOperation):
             )
         return False
 
-    def map_qubits(self, qubit_map: Dict[raw_types.Qid, raw_types.Qid]) -> 'PauliStringPhasor':
+    def map_qubits(self, qubit_map: dict[raw_types.Qid, raw_types.Qid]) -> PauliStringPhasor:
         """Maps the qubits inside the PauliStringPhasor.
 
         Args:
@@ -168,13 +160,13 @@ class PauliStringPhasor(gate_operation.GateOperation):
             exponent_pos=self.exponent_pos,
         )
 
-    def can_merge_with(self, op: 'PauliStringPhasor') -> bool:
+    def can_merge_with(self, op: PauliStringPhasor) -> bool:
         """Checks whether the underlying PauliStrings can be merged."""
         return (
             self.pauli_string.equal_up_to_coefficient(op.pauli_string) and self.qubits == op.qubits
         )
 
-    def merged_with(self, op: 'PauliStringPhasor') -> 'PauliStringPhasor':
+    def merged_with(self, op: PauliStringPhasor) -> PauliStringPhasor:
         """Merges two PauliStringPhasors."""
         if not self.can_merge_with(op):
             raise ValueError(f'Cannot merge operations: {self}, {op}')
@@ -184,9 +176,7 @@ class PauliStringPhasor(gate_operation.GateOperation):
             self.pauli_string, qubits=self.qubits, exponent_pos=pp, exponent_neg=pn
         )
 
-    def _circuit_diagram_info_(
-        self, args: 'cirq.CircuitDiagramInfoArgs'
-    ) -> 'cirq.CircuitDiagramInfo':
+    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> cirq.CircuitDiagramInfo:
         qubits = self.qubits if args.known_qubits is None else args.known_qubits
         if not qubits:
             return NotImplemented
@@ -199,9 +189,21 @@ class PauliStringPhasor(gate_operation.GateOperation):
         syms = tuple(sym(qubit) for qubit in qubits)
         return protocols.CircuitDiagramInfo(wire_symbols=syms, exponent=self.exponent_relative)
 
+    def conjugated_by(self, clifford: cirq.OP_TREE) -> PauliStringPhasor:
+        r"""Returns the Pauli string conjugated by a clifford operation.
+
+        The PauliStringPhasor $P$ conjugated by the Clifford operation $C$ is
+          $C^\dagger P C$.
+        """
+        new_pauli_string: ps.PauliString = self.pauli_string.conjugated_by(clifford)
+        pp = self.exponent_pos
+        pn = self.exponent_neg
+        return PauliStringPhasor(new_pauli_string, exponent_pos=pp, exponent_neg=pn)
+
+    @deprecated(deadline="v2.0", fix="Use conjuagetd_by() instead.")
     def pass_operations_over(
         self, ops: Iterable[raw_types.Operation], after_to_before: bool = False
-    ) -> 'PauliStringPhasor':
+    ) -> PauliStringPhasor:  # pragma: no cover
         """Determines how the Pauli phasor changes when conjugated by Cliffords.
 
         The output and input pauli phasors are related by a circuit equivalence.
@@ -228,7 +230,12 @@ class PauliStringPhasor(gate_operation.GateOperation):
                 pauli string, instead of before (and so are moving in the
                 opposite direction).
         """
-        new_pauli_string = self.pauli_string.pass_operations_over(ops, after_to_before)
+        new_pauli_string: ps.PauliString = ps.PauliString()
+        if after_to_before:
+            new_pauli_string = self.pauli_string.after(ops)
+        else:
+            all_ops = list(op_tree.flatten_to_ops(ops))
+            new_pauli_string = self.pauli_string.before(all_ops[::-1])
         pp = self.exponent_pos
         pn = self.exponent_neg
         return PauliStringPhasor(new_pauli_string, exponent_pos=pp, exponent_neg=pn)
@@ -277,8 +284,8 @@ class PauliStringPhasorGate(raw_types.Gate):
         self,
         dense_pauli_string: dps.DensePauliString,
         *,
-        exponent_neg: 'cirq.TParamVal' = 1,
-        exponent_pos: 'cirq.TParamVal' = 0,
+        exponent_neg: cirq.TParamVal = 1,
+        exponent_pos: cirq.TParamVal = 0,
     ) -> None:
         """Initializes the PauliStringPhasorGate.
 
@@ -308,29 +315,29 @@ class PauliStringPhasorGate(raw_types.Gate):
         self._exponent_pos = value.canonicalize_half_turns(exponent_pos)
 
     @property
-    def exponent_relative(self) -> 'cirq.TParamVal':
+    def exponent_relative(self) -> cirq.TParamVal:
         """The relative exponent between negative and positive exponents."""
         return value.canonicalize_half_turns(self.exponent_neg - self.exponent_pos)
 
     @property
-    def exponent_neg(self) -> 'cirq.TParamVal':
+    def exponent_neg(self) -> cirq.TParamVal:
         """The negative exponent."""
         return self._exponent_neg
 
     @property
-    def exponent_pos(self) -> 'cirq.TParamVal':
+    def exponent_pos(self) -> cirq.TParamVal:
         """The positive exponent."""
         return self._exponent_pos
 
     @property
-    def dense_pauli_string(self) -> 'cirq.DensePauliString':
+    def dense_pauli_string(self) -> cirq.DensePauliString:
         """The underlying DensePauliString."""
         return self._dense_pauli_string
 
     def _value_equality_values_(self):
         return (self.dense_pauli_string, self.exponent_neg, self.exponent_pos)
 
-    def equal_up_to_global_phase(self, other: 'cirq.PauliStringPhasorGate') -> bool:
+    def equal_up_to_global_phase(self, other: cirq.PauliStringPhasorGate) -> bool:
         """Checks equality of two PauliStringPhasors, up to global phase."""
         if isinstance(other, PauliStringPhasorGate):
             rel1 = self.exponent_relative
@@ -338,7 +345,7 @@ class PauliStringPhasorGate(raw_types.Gate):
             return rel1 == rel2 and self.dense_pauli_string == other.dense_pauli_string
         return False
 
-    def __pow__(self, exponent: Union[float, sympy.Symbol]) -> 'PauliStringPhasorGate':
+    def __pow__(self, exponent: float | sympy.Symbol) -> PauliStringPhasorGate:
         pn = protocols.mul(self.exponent_neg, exponent, None)
         pp = protocols.mul(self.exponent_pos, exponent, None)
         if pn is None or pp is None:
@@ -348,11 +355,11 @@ class PauliStringPhasorGate(raw_types.Gate):
     def _has_unitary_(self) -> bool:
         return not self._is_parameterized_()
 
-    def _to_z_basis_ops(self, qubits: Sequence['cirq.Qid']) -> Iterator[raw_types.Operation]:
+    def _to_z_basis_ops(self, qubits: Sequence[cirq.Qid]) -> Iterator[raw_types.Operation]:
         """Returns operations to convert the qubits to the computational basis."""
         return self.dense_pauli_string.on(*qubits).to_z_basis_ops()
 
-    def _decompose_(self, qubits: Sequence['cirq.Qid']) -> Iterator['cirq.OP_TREE']:
+    def _decompose_(self, qubits: Sequence[cirq.Qid]) -> Iterator[cirq.OP_TREE]:
         if len(self.dense_pauli_string) <= 0:
             return
         any_qubit = qubits[0]
@@ -387,8 +394,8 @@ class PauliStringPhasorGate(raw_types.Gate):
         )
 
     def _resolve_parameters_(
-        self, resolver: 'cirq.ParamResolver', recursive: bool
-    ) -> 'PauliStringPhasorGate':
+        self, resolver: cirq.ParamResolver, recursive: bool
+    ) -> PauliStringPhasorGate:
         exponent_neg = resolver.value_of(self.exponent_neg, recursive)
         exponent_pos = resolver.value_of(self.exponent_pos, recursive)
         if isinstance(exponent_neg, numbers.Complex):
@@ -427,7 +434,7 @@ class PauliStringPhasorGate(raw_types.Gate):
         """The number of qubits for the gate."""
         return len(self.dense_pauli_string)
 
-    def on(self, *qubits: 'cirq.Qid') -> 'cirq.PauliStringPhasor':
+    def on(self, *qubits: cirq.Qid) -> cirq.PauliStringPhasor:
         """Creates a PauliStringPhasor on the qubits."""
         return PauliStringPhasor(
             self.dense_pauli_string.on(*qubits),
@@ -443,7 +450,7 @@ class PauliStringPhasorGate(raw_types.Gate):
 
 
 def xor_nonlocal_decompose(
-    qubits: Iterable[raw_types.Qid], onto_qubit: 'cirq.Qid'
+    qubits: Iterable[raw_types.Qid], onto_qubit: cirq.Qid
 ) -> Iterable[raw_types.Operation]:
     """Decomposition ignores connectivity."""
     for qubit in qubits:

cirq/ops/pauli_string_phasor_test.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import itertools
 
 import numpy as np
@@ -155,7 +157,7 @@ def test_consistent():
     cirq.testing.assert_implements_consistent_protocols(p)
 
 
-def test_pass_operations_over():
+def test_conjugated_by():
     q0, q1 = _make_qubits(2)
     op = cirq.SingleQubitCliffordGate.from_double_map(
         {cirq.Z: (cirq.X, False), cirq.X: (cirq.Z, False)}
@@ -164,10 +166,7 @@ def test_pass_operations_over():
     ps_after = cirq.PauliString({q0: cirq.Z, q1: cirq.Y}, -1)
     before = cirq.PauliStringPhasor(ps_before, exponent_neg=0.1)
     after = cirq.PauliStringPhasor(ps_after, exponent_neg=0.1)
-    assert before.pass_operations_over([op]).pauli_string == after.pauli_string
-    assert (
-        after.pass_operations_over([op], after_to_before=True).pauli_string == before.pauli_string
-    )
+    assert before.conjugated_by(op).pauli_string == after.pauli_string
 
 
 def test_extrapolate_effect():

cirq/ops/pauli_string_raw_types.py

@@ -12,8 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import abc
-from typing import Any, Dict, Sequence, Tuple, TYPE_CHECKING
+from typing import Any, Sequence, TYPE_CHECKING
 
 from typing_extensions import Self
 
@@ -29,19 +31,19 @@ class PauliStringGateOperation(raw_types.Operation, metaclass=abc.ABCMeta):
         self._pauli_string = pauli_string
 
     @property
-    def pauli_string(self) -> 'cirq.PauliString':
+    def pauli_string(self) -> cirq.PauliString:
         return self._pauli_string
 
     def validate_args(self, qubits: Sequence[raw_types.Qid]) -> None:
         if len(qubits) != len(self.pauli_string):
             raise ValueError('Incorrect number of qubits for gate')
 
-    def with_qubits(self, *new_qubits: 'cirq.Qid') -> Self:
+    def with_qubits(self, *new_qubits: cirq.Qid) -> Self:
         self.validate_args(new_qubits)
         return self.map_qubits(dict(zip(self.pauli_string.qubits, new_qubits)))
 
     @abc.abstractmethod
-    def map_qubits(self, qubit_map: Dict[raw_types.Qid, raw_types.Qid]) -> Self:
+    def map_qubits(self, qubit_map: dict[raw_types.Qid, raw_types.Qid]) -> Self:
         """Return an equivalent operation on new qubits with its Pauli string
         mapped to new qubits.
 
@@ -49,12 +51,12 @@ class PauliStringGateOperation(raw_types.Operation, metaclass=abc.ABCMeta):
         """
 
     @property
-    def qubits(self) -> Tuple[raw_types.Qid, ...]:
+    def qubits(self) -> tuple[raw_types.Qid, ...]:
         return tuple(self.pauli_string)
 
     def _pauli_string_diagram_info(
-        self, args: 'protocols.CircuitDiagramInfoArgs', exponent: Any = 1
-    ) -> 'cirq.CircuitDiagramInfo':
+        self, args: protocols.CircuitDiagramInfoArgs, exponent: Any = 1
+    ) -> cirq.CircuitDiagramInfo:
         qubits = self.qubits if args.known_qubits is None else args.known_qubits
         syms = tuple(f'[{self.pauli_string[qubit]}]' for qubit in qubits)
         return protocols.CircuitDiagramInfo(wire_symbols=syms, exponent=exponent)

cirq/ops/pauli_string_raw_types_test.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import pytest
 
 import cirq

cirq/ops/pauli_string_test.py

@@ -12,9 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import itertools
 import math
-from typing import List
 
 import numpy as np
 import pytest
@@ -336,9 +337,7 @@ def test_get(qubit_pauli_map):
         assert qubit_pauli_map.get(key) == pauli_string.get(key)
     assert qubit_pauli_map.get(other) is None
     assert pauli_string.get(other) is None
-    # pylint: disable=too-many-function-args
     assert qubit_pauli_map.get(other, 5) == pauli_string.get(other, 5) == 5
-    # pylint: enable=too-many-function-args
 
 
 @pytest.mark.parametrize('qubit_pauli_map', _sample_qubit_pauli_maps())
@@ -723,118 +722,6 @@ def test_to_z_basis_ops_product_state():
     )
 
 
-def _assert_pass_over(ops: List[cirq.Operation], before: cirq.PauliString, after: cirq.PauliString):
-    assert before.pass_operations_over(ops[::-1]) == after
-    assert after.pass_operations_over(ops, after_to_before=True) == before
-
-
-@pytest.mark.parametrize('shift,sign', itertools.product(range(3), (-1, +1)))
-def test_pass_operations_over_single(shift: int, sign: int):
-    q0, q1 = _make_qubits(2)
-    X, Y, Z = (cirq.Pauli.by_relative_index(pauli, shift) for pauli in (cirq.X, cirq.Y, cirq.Z))
-
-    op0 = cirq.SingleQubitCliffordGate.from_pauli(Y)(q1)
-    ps_before: cirq.PauliString[cirq.Qid] = cirq.PauliString({q0: X}, sign)
-    ps_after = ps_before
-    _assert_pass_over([op0], ps_before, ps_after)
-
-    op0 = cirq.SingleQubitCliffordGate.from_pauli(X)(q0)
-    op1 = cirq.SingleQubitCliffordGate.from_pauli(Y)(q1)
-    ps_before = cirq.PauliString({q0: X, q1: Y}, sign)
-    ps_after = ps_before
-    _assert_pass_over([op0, op1], ps_before, ps_after)
-
-    op0 = cirq.SingleQubitCliffordGate.from_double_map({Z: (X, False), X: (Z, False)})(q0)
-    ps_before = cirq.PauliString({q0: X, q1: Y}, sign)
-    ps_after = cirq.PauliString({q0: Z, q1: Y}, sign)
-    _assert_pass_over([op0], ps_before, ps_after)
-
-    op1 = cirq.SingleQubitCliffordGate.from_pauli(X)(q1)
-    ps_before = cirq.PauliString({q0: X, q1: Y}, sign)
-    ps_after = -ps_before
-    _assert_pass_over([op1], ps_before, ps_after)
-
-    ps_after = cirq.PauliString({q0: Z, q1: Y}, -sign)
-    _assert_pass_over([op0, op1], ps_before, ps_after)
-
-    op0 = cirq.SingleQubitCliffordGate.from_pauli(Z, True)(q0)
-    op1 = cirq.SingleQubitCliffordGate.from_pauli(X, True)(q0)
-    ps_before = cirq.PauliString({q0: X}, sign)
-    ps_after = cirq.PauliString({q0: Y}, -sign)
-    _assert_pass_over([op0, op1], ps_before, ps_after)
-
-
-@pytest.mark.parametrize(
-    'shift,t_or_f1, t_or_f2,neg', itertools.product(range(3), *((True, False),) * 3)
-)
-def test_pass_operations_over_double(shift: int, t_or_f1: bool, t_or_f2: bool, neg: bool):
-    sign = -1 if neg else +1
-    q0, q1, q2 = _make_qubits(3)
-    X, Y, Z = (cirq.Pauli.by_relative_index(pauli, shift) for pauli in (cirq.X, cirq.Y, cirq.Z))
-
-    op0 = cirq.PauliInteractionGate(Z, t_or_f1, X, t_or_f2)(q0, q1)
-    ps_before = cirq.PauliString(qubit_pauli_map={q0: Z, q2: Y}, coefficient=sign)
-    ps_after = cirq.PauliString(qubit_pauli_map={q0: Z, q2: Y}, coefficient=sign)
-    assert_conjugation(ps_before, op0, ps_after, True)
-    _assert_pass_over([op0], ps_before, ps_after)
-
-    op0 = cirq.PauliInteractionGate(Y, t_or_f1, X, t_or_f2)(q0, q1)
-    ps_before = cirq.PauliString({q0: Z, q2: Y}, sign)
-    ps_after = cirq.PauliString({q0: Z, q2: Y, q1: X}, -sign if t_or_f2 else sign)
-    assert_conjugation(ps_before, op0, ps_after, True)
-    _assert_pass_over([op0], ps_before, ps_after)
-
-    op0 = cirq.PauliInteractionGate(Z, t_or_f1, X, t_or_f2)(q0, q1)
-    ps_before = cirq.PauliString({q0: Z, q1: Y}, sign)
-    ps_after = cirq.PauliString({q1: Y}, -sign if t_or_f1 else sign)
-    assert_conjugation(ps_before, op0, ps_after, True)
-    _assert_pass_over([op0], ps_before, ps_after)
-
-    op0 = cirq.PauliInteractionGate(Y, t_or_f1, X, t_or_f2)(q0, q1)
-    ps_before = cirq.PauliString({q0: Z, q1: Y}, sign)
-    ps_after = cirq.PauliString({q0: X, q1: Z}, -1 if neg ^ t_or_f1 ^ t_or_f2 else +1)
-    assert_conjugation(ps_before, op0, ps_after, True)
-    _assert_pass_over([op0], ps_before, ps_after)
-
-    op0 = cirq.PauliInteractionGate(X, t_or_f1, X, t_or_f2)(q0, q1)
-    ps_before = cirq.PauliString({q0: Z, q1: Y}, sign)
-    ps_after = cirq.PauliString({q0: Y, q1: Z}, +1 if neg ^ t_or_f1 ^ t_or_f2 else -1)
-    assert_conjugation(ps_before, op0, ps_after, True)
-    _assert_pass_over([op0], ps_before, ps_after)
-
-
-def test_pass_operations_over_cz():
-    q0, q1 = _make_qubits(2)
-    op0 = cirq.CZ(q0, q1)
-    ps_before = cirq.PauliString({q0: cirq.Z, q1: cirq.Y})
-    ps_after = cirq.PauliString({q1: cirq.Y})
-    _assert_pass_over([op0], ps_before, ps_after)
-
-
-def test_pass_operations_over_no_common_qubits():
-    class ExampleGate(cirq.testing.SingleQubitGate):
-
-        def _decompose_(self, qubits):
-            return cirq.X(qubits[0])
-
-    q0, q1 = _make_qubits(2)
-    op0 = ExampleGate()(q1)
-    ps_before = cirq.PauliString({q0: cirq.Z})
-    ps_after = cirq.PauliString({q0: cirq.Z})
-    _assert_pass_over([op0], ps_before, ps_after)
-
-
-def test_pass_unsupported_operations_over():
-    (q0,) = _make_qubits(1)
-    pauli_string = cirq.PauliString({q0: cirq.X})
-    with pytest.raises(
-        ValueError,
-        match='Clifford Gate can only be constructed from the operations'
-        ' that has stabilizer effect.',
-    ):
-        pauli_string.pass_operations_over([cirq.T(q0)])
-
-
 def test_with_qubits():
     old_qubits = cirq.LineQubit.range(9)
     new_qubits = cirq.LineQubit.range(9, 18)
@@ -1637,40 +1524,6 @@ def test_conjugated_by_ordering():
     assert out1 == out2 == cirq.X(a) * cirq.Z(b)
 
 
-def test_pass_operations_over_ordering():
-    class OrderSensitiveGate(cirq.Gate):
-        def num_qubits(self):
-            return 2
-
-        def _decompose_(self, qubits):
-            return [cirq.Y(qubits[0]) ** -0.5, cirq.CNOT(*qubits)]
-
-    a, b = cirq.LineQubit.range(2)
-    inp = cirq.Z(b)
-    out1 = inp.pass_operations_over(OrderSensitiveGate().on(a, b))
-    out2 = inp.pass_operations_over([cirq.CNOT(a, b), cirq.Y(a) ** -0.5])
-    out3 = inp.pass_operations_over([cirq.CNOT(a, b)]).pass_operations_over([cirq.Y(a) ** -0.5])
-    assert out1 == out2 == out3 == cirq.X(a) * cirq.Z(b)
-
-
-def test_pass_operations_over_ordering_reversed():
-    class OrderSensitiveGate(cirq.Gate):
-        def num_qubits(self):
-            return 2
-
-        def _decompose_(self, qubits):
-            return [cirq.Y(qubits[0]) ** -0.5, cirq.CNOT(*qubits)]
-
-    a, b = cirq.LineQubit.range(2)
-    inp = cirq.X(a) * cirq.Z(b)
-    out1 = inp.pass_operations_over(OrderSensitiveGate().on(a, b), after_to_before=True)
-    out2 = inp.pass_operations_over([cirq.Y(a) ** -0.5, cirq.CNOT(a, b)], after_to_before=True)
-    out3 = inp.pass_operations_over([cirq.Y(a) ** -0.5], after_to_before=True).pass_operations_over(
-        [cirq.CNOT(a, b)], after_to_before=True
-    )
-    assert out1 == out2 == out3 == cirq.Z(b)
-
-
 def test_pretty_print():
     a, b, c = cirq.LineQubit.range(3)
     result = cirq.PauliString({a: 'x', b: 'y', c: 'z'})
@@ -1693,7 +1546,6 @@ def test_pretty_print():
     assert p.text_pretty == 'cirq.PauliString(...)'
 
 
-# pylint: disable=line-too-long
 def test_circuit_diagram_info():
     a, b, c = cirq.LineQubit.range(3)
 
@@ -1714,13 +1566,10 @@ def test_circuit_diagram_info():
 1: ───────────────────────────────────────┼─────────────────Y─────────────────PauliString(-iY)───Y───────────────────────────────
                                           │
 2: ───────────────────────────────────────Z──────────────────────────────────────────────────────────────────────────────────────
-        """,
+        """,  # noqa: E501
     )
 
 
-# pylint: enable=line-too-long
-
-
 def test_mutable_pauli_string_init_raises():
     q = cirq.LineQubit.range(3)
     with pytest.raises(ValueError, match='must be between 1 and 3'):
@@ -2137,3 +1986,31 @@ def test_resolve(resolve_fn):
     pst = cirq.PauliString({q: 'x'}, coefficient=t)
     ps1 = cirq.PauliString({q: 'x'}, coefficient=1j)
     assert resolve_fn(pst, {'t': 1j}) == ps1
+
+
+@pytest.mark.parametrize(
+    'gate1,gate2',
+    [
+        (cirq.I, cirq.I),
+        (cirq.I, cirq.X),
+        (cirq.I, cirq.Y),
+        (cirq.I, cirq.Z),
+        (cirq.X, cirq.I),
+        (cirq.Y, cirq.I),
+        (cirq.Z, cirq.I),
+    ],
+    ids=str,
+)
+def test_pauli_ops_identity_gate_operation(gate1: cirq.Pauli, gate2: cirq.Pauli) -> None:
+    # TODO: Issue #7280 - Support addition and subtraction of identity gate operations.
+    if gate1 == gate2 == cirq.I:
+        pytest.skip('Not yet implemented per #7280')
+    q = cirq.LineQubit(0)
+    pauli1, pauli2 = gate1.on(q), gate2.on(q)
+    unitary1, unitary2 = cirq.unitary(gate1), cirq.unitary(gate2)
+    addition = pauli1 + pauli2
+    assert isinstance(addition, cirq.PauliSum)
+    assert np.array_equal(addition.matrix(), unitary1 + unitary2)
+    subtraction = pauli1 - pauli2
+    assert isinstance(subtraction, cirq.PauliSum)
+    assert np.array_equal(subtraction.matrix(), unitary1 - unitary2)

cirq/ops/pauli_sum_exponential.py

@@ -11,7 +11,10 @@
 # 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 typing import Any, Iterator, Tuple, TYPE_CHECKING
+
+from __future__ import annotations
+
+from typing import Any, Iterator, TYPE_CHECKING
 
 import numpy as np
 
@@ -22,7 +25,7 @@ if TYPE_CHECKING:
     import cirq
 
 
-def _all_pauli_strings_commute(pauli_sum: 'cirq.PauliSum') -> bool:
+def _all_pauli_strings_commute(pauli_sum: cirq.PauliSum) -> bool:
     for x in pauli_sum:
         for y in pauli_sum:
             if not protocols.commutes(x, y):
@@ -42,10 +45,7 @@ class PauliSumExponential:
     """
 
     def __init__(
-        self,
-        pauli_sum_like: 'cirq.PauliSumLike',
-        exponent: 'cirq.TParamVal' = 1,
-        atol: float = 1e-8,
+        self, pauli_sum_like: cirq.PauliSumLike, exponent: cirq.TParamVal = 1, atol: float = 1e-8
     ):
         pauli_sum = linear_combinations.PauliSum.wrap(pauli_sum_like)
         if not _all_pauli_strings_commute(pauli_sum):
@@ -68,13 +68,13 @@ class PauliSumExponential:
         self._pauli_sum = pauli_sum
 
     @property
-    def qubits(self) -> Tuple['cirq.Qid', ...]:
+    def qubits(self) -> tuple[cirq.Qid, ...]:
         return self._pauli_sum.qubits
 
     def _value_equality_values_(self) -> Any:
         return (self._pauli_sum, self._exponent)
 
-    def with_qubits(self, *new_qubits: 'cirq.Qid') -> 'PauliSumExponential':
+    def with_qubits(self, *new_qubits: cirq.Qid) -> PauliSumExponential:
         return PauliSumExponential(self._pauli_sum.with_qubits(*new_qubits), self._exponent)
 
     @_compat.cached_method
@@ -82,14 +82,14 @@ class PauliSumExponential:
         return protocols.is_parameterized(self._exponent)
 
     def _resolve_parameters_(
-        self, resolver: 'cirq.ParamResolver', recursive: bool
-    ) -> 'PauliSumExponential':
+        self, resolver: cirq.ParamResolver, recursive: bool
+    ) -> PauliSumExponential:
         return PauliSumExponential(
             self._pauli_sum,
             exponent=protocols.resolve_parameters(self._exponent, resolver, recursive),
         )
 
-    def __iter__(self) -> Iterator['cirq.PauliStringPhasor']:
+    def __iter__(self) -> Iterator[cirq.PauliStringPhasor]:
         for pauli_string in self._pauli_sum:
             theta = pauli_string.coefficient * self._multiplier
             theta *= self._exponent / np.pi
@@ -119,7 +119,7 @@ class PauliSumExponential:
     def _unitary_(self) -> np.ndarray:
         return self.matrix()
 
-    def __pow__(self, exponent: int) -> 'PauliSumExponential':
+    def __pow__(self, exponent: int) -> PauliSumExponential:
         return PauliSumExponential(self._pauli_sum, self._exponent * exponent)
 
     def __repr__(self) -> str: