[bugfix] Prevent GateOperation.add from superseding Circuit.radd (#7707)

Per issue #7706, the change in #7651 caused `Circuit.__radd__`, which
allows `+` to prepend operations to circuits, e.g. `H(q) + Circuit(...)
== Circuit(H(q), ...)`, to stop working. The root cause is that the
change added a `GateOperation.__add__`, which thus supersedes
`Circuit.__radd__` and changes the behavior of `+` in such cases.

The fix for this is to modify the new `GateOperation.__add__` (and
`GateOperation.__sub__`, for symmetry) so that it only applies in cases
where interpreting the sum as a `PauliString` is reasonable.

To do this, first, I updated `GateOperation.__add__` with a check, `if
not isinstance(other, (Operation, Number)): return NotImplemented`,
since ops and numbers are the only things that can be interpreted as a
`PauliString`. This change prevents `GateOperation.__add__` from
interfering with `Circuit.__radd__`, and constitutes the crux of the
fix.

That change in isolation breaks `GateOperation + PauliSum` because the
latter isn't an `Operation`. The simplest fix for *this* would be to add
`PauliSum` to the new isinstance check, e.g. `isinstance(other,
(Operation, Number, PauliSum))`, However that approach adds `PauliSum`
as a dependency of `GateOperation`, which seems unnatural. So instead, I
added logic in `PauliSum.__add__` to convert ops to `PauliString` first.
That approach doesn't create any new dependencies, and is also more
robust because it works for *all* operations, not just GateOperations.

(Note, an even simpler fix for the entire issue would have been, instead
of allowlisting `(Operation, Number)` in `GateOperation.__add__`, to
denylist `Circuit` instead, e.g. `if isinstance(other, Circuit): return
NotImplemented`. That would have fixed the issue and not required any
special change for `PauliSum`. But similarly, I chose against that route
because of the unnatural dependency it would create, as well as the fact
that that fix wouldn't help if any third-party classes used `radd` on
operations in the same way `Circuit` does.)

Finally, I updated the `Circuit.radd` unit test to include assertions
that would have broken under the old code. The existing test used `X`
gates everywhere, which didn't fail when prepending because of misc
internal logic for Pauli gates. So I parameterized the test on `gate`,
and added a non-Pauli gate `H` to the parameters, which will now fail if
a similar regression is made in the future. I updated some tests in
linear_combinations to test `__sub__` more thoroughly as well, for
symmetry.

Key takeaway: be careful when implementing `__add__` for an existing
class, and limit the scope of `other` to which it can apply, as
otherwise the change can break `__radd__` functionality in unrelated
classes.

Fixes #7706

---------

Co-authored-by: Pavol Juhas <pavol.juhas@gmail.com>

Author: daxfohl

cirq-core/cirq/circuits/circuit_test.py

@@ -356,20 +356,21 @@ def test_add_op_tree(circuit_cls) -> None:
 
 
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
-def test_radd_op_tree(circuit_cls) -> None:
+@pytest.mark.parametrize('gate', [cirq.X, cirq.H])
+def test_radd_op_tree(circuit_cls, gate) -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
 
     c = circuit_cls()
-    assert [cirq.X(a), cirq.Y(b)] + c == circuit_cls([cirq.Moment([cirq.X(a), cirq.Y(b)])])
+    assert [gate(a), cirq.Y(b)] + c == circuit_cls([cirq.Moment([gate(a), cirq.Y(b)])])
 
-    assert cirq.X(a) + c == circuit_cls(cirq.X(a))
-    assert [cirq.X(a)] + c == circuit_cls(cirq.X(a))
-    assert [[[cirq.X(a)], []]] + c == circuit_cls(cirq.X(a))
-    assert (cirq.X(a),) + c == circuit_cls(cirq.X(a))
-    assert (cirq.X(a) for _ in range(1)) + c == circuit_cls(cirq.X(a))
+    assert gate(a) + c == circuit_cls(gate(a))
+    assert [gate(a)] + c == circuit_cls(gate(a))
+    assert [[[gate(a)], []]] + c == circuit_cls(gate(a))
+    assert (gate(a),) + c == circuit_cls(gate(a))
+    assert (gate(a) for _ in range(1)) + c == circuit_cls(gate(a))
     with pytest.raises(AttributeError):
-        _ = cirq.X + c
+        _ = gate + c
     with pytest.raises(TypeError):
         _ = 0 + c
 
@@ -380,9 +381,9 @@ def test_radd_op_tree(circuit_cls) -> None:
     else:
         d = cirq.Circuit()
         d.append(cirq.Y(b))
-    assert [cirq.X(a)] + d == circuit_cls([cirq.Moment([cirq.X(a)]), cirq.Moment([cirq.Y(b)])])
-    assert cirq.Moment([cirq.X(a)]) + d == circuit_cls(
-        [cirq.Moment([cirq.X(a)]), cirq.Moment([cirq.Y(b)])]
+    assert [gate(a)] + d == circuit_cls([cirq.Moment([gate(a)]), cirq.Moment([cirq.Y(b)])])
+    assert cirq.Moment([gate(a)]) + d == circuit_cls(
+        [cirq.Moment([gate(a)]), cirq.Moment([cirq.Y(b)])]
     )
 
 

cirq-core/cirq/ops/gate_operation.py

@@ -16,6 +16,7 @@
 
 from __future__ import annotations
 
+import numbers
 import re
 import warnings
 from collections.abc import Collection, Mapping, Sequence, Set
@@ -323,12 +324,16 @@ def __rmul__(self, other: Any) -> Any:
         return self.gate._rmul_with_qubits(self._qubits, other)
 
     def __add__(self, other):
+        if not isinstance(other, (ops.Operation, numbers.Number)):
+            return NotImplemented
         return 1 * self + other
 
     def __radd__(self, other):
         return other + 1 * self
 
     def __sub__(self, other):
+        if not isinstance(other, (ops.Operation, numbers.Number)):
+            return NotImplemented
         return 1 * self - other
 
     def __rsub__(self, other):

cirq-core/cirq/ops/linear_combinations.py

@@ -743,6 +743,8 @@ def __len__(self) -> int:
         return len(self._linear_dict)
 
     def __iadd__(self, other):
+        if isinstance(other, raw_types.Operation):
+            other = pauli_string._try_interpret_as_pauli_string(other)
         if isinstance(other, numbers.Complex):
             other = PauliSum.from_pauli_strings([PauliString(coefficient=other)])
         elif isinstance(other, PauliString):
@@ -767,6 +769,8 @@ def __rsub__(self, other):
         return -self.__sub__(other)
 
     def __isub__(self, other):
+        if isinstance(other, raw_types.Operation):
+            other = pauli_string._try_interpret_as_pauli_string(other)
         if isinstance(other, numbers.Complex):
             other = PauliSum.from_pauli_strings([PauliString(coefficient=other)])
         elif isinstance(other, PauliString):

cirq-core/cirq/ops/linear_combinations_test.py

@@ -975,10 +975,16 @@ def test_paulisum_validation() -> None:
     ps += cirq.I(cirq.LineQubit(0))
     assert ps == cirq.PauliSum(cirq.LinearDict({frozenset(): complex(1)}))
 
+    ps = cirq.I(cirq.LineQubit(0)) + cirq.PauliSum()
+    assert ps == cirq.PauliSum(cirq.LinearDict({frozenset(): complex(1)}))
+
     ps = cirq.PauliSum()
     ps -= cirq.I(cirq.LineQubit(0))
     assert ps == cirq.PauliSum(cirq.LinearDict({frozenset(): complex(-1)}))
 
+    ps = cirq.I(cirq.LineQubit(0)) - cirq.PauliSum()
+    assert ps == cirq.PauliSum(cirq.LinearDict({frozenset(): complex(1)}))
+
 
 def test_add_number_paulisum() -> None:
     q = cirq.LineQubit.range(2)
@@ -1008,6 +1014,22 @@ def test_add_number_paulistring() -> None:
         == cirq.PauliSum.from_pauli_strings([cirq.PauliString() * 2, cirq.PauliString({a: cirq.X})])
     )
 
+    assert (
+        cirq.X(a) - 2
+        == -2 + cirq.X(a)
+        == cirq.PauliSum.from_pauli_strings(
+            [cirq.PauliString() * -2, cirq.PauliString({a: cirq.X})]
+        )
+    )
+
+    assert (
+        2 - cirq.X(a)
+        == 2 + -cirq.X(a)
+        == cirq.PauliSum.from_pauli_strings(
+            [cirq.PauliString() * 2, -cirq.PauliString({a: cirq.X})]
+        )
+    )
+
 
 def test_pauli_sum_formatting() -> None:
     q = cirq.LineQubit.range(2)