cirq-core 1.7.0.dev20250825174419__py3-none-any.whl → 1.7.0.dev20251203004401__py3-none-any.whl

cirq/ops/controlled_operation.py

@@ -14,8 +14,9 @@
 
 from __future__ import annotations
 
+from collections.abc import Collection, Sequence, Set
 from types import EllipsisType, NotImplementedType
-from typing import AbstractSet, Any, Collection, Sequence, TYPE_CHECKING
+from typing import Any, TYPE_CHECKING
 
 import numpy as np
 
@@ -261,7 +262,7 @@ class ControlledOperation(raw_types.Operation):
     def _is_parameterized_(self) -> bool:
         return protocols.is_parameterized(self.sub_operation)
 
-    def _parameter_names_(self) -> AbstractSet[str]:
+    def _parameter_names_(self) -> Set[str]:
         return protocols.parameter_names(self.sub_operation)
 
     def _resolve_parameters_(

cirq/ops/controlled_operation_test.py

@@ -16,8 +16,9 @@ from __future__ import annotations
 
 import itertools
 import re
+from collections.abc import Sequence
 from types import EllipsisType, NotImplementedType
-from typing import cast, Sequence
+from typing import cast
 
 import numpy as np
 import pytest

cirq/ops/dense_pauli_string.py

@@ -16,19 +16,9 @@ from __future__ import annotations
 
 import abc
 import numbers
+from collections.abc import Callable, Iterable, Iterator, Sequence, Set
 from types import NotImplementedType
-from typing import (
-    AbstractSet,
-    Any,
-    Callable,
-    cast,
-    Iterable,
-    Iterator,
-    overload,
-    Self,
-    Sequence,
-    TYPE_CHECKING,
-)
+from typing import Any, cast, overload, Self, TYPE_CHECKING
 
 import numpy as np
 import sympy
@@ -187,7 +177,7 @@ class BaseDensePauliString(raw_types.Gate, metaclass=abc.ABCMeta):
     def _is_parameterized_(self) -> bool:
         return protocols.is_parameterized(self.coefficient)
 
-    def _parameter_names_(self) -> AbstractSet[str]:
+    def _parameter_names_(self) -> Set[str]:
         return protocols.parameter_names(self.coefficient)
 
     def _resolve_parameters_(self, resolver: cirq.ParamResolver, recursive: bool) -> Self:
@@ -247,35 +237,25 @@ class BaseDensePauliString(raw_types.Gate, metaclass=abc.ABCMeta):
 
     def __mul__(self, other):
         concrete_class = type(self)
-        if isinstance(other, BaseDensePauliString):
-            if isinstance(other, MutableDensePauliString):
-                concrete_class = MutableDensePauliString
-            max_len = max(len(self.pauli_mask), len(other.pauli_mask))
-            min_len = min(len(self.pauli_mask), len(other.pauli_mask))
-            new_mask = np.zeros(max_len, dtype=np.uint8)
-            new_mask[: len(self.pauli_mask)] ^= self.pauli_mask
-            new_mask[: len(other.pauli_mask)] ^= other.pauli_mask
-            tweak = _vectorized_pauli_mul_phase(
-                self.pauli_mask[:min_len], other.pauli_mask[:min_len]
-            )
-            return concrete_class(
-                pauli_mask=new_mask, coefficient=self.coefficient * other.coefficient * tweak
-            )
-
         if isinstance(other, (sympy.Basic, numbers.Number)):
             new_coef = protocols.mul(self.coefficient, other, default=None)
             if new_coef is None:
                 return NotImplemented
             return concrete_class(pauli_mask=self.pauli_mask, coefficient=new_coef)
 
-        split = _attempt_value_to_pauli_index(other)
-        if split is not None:
-            p, i = split
-            mask = np.copy(self.pauli_mask)
-            mask[i] ^= p
+        if (other_dps := _try_interpret_as_dps(other)) is not None:
+            if isinstance(other_dps, MutableDensePauliString):
+                concrete_class = MutableDensePauliString
+            max_len = max(len(self.pauli_mask), len(other_dps.pauli_mask))
+            min_len = min(len(self.pauli_mask), len(other_dps.pauli_mask))
+            new_mask = np.zeros(max_len, dtype=np.uint8)
+            new_mask[: len(self.pauli_mask)] ^= self.pauli_mask
+            new_mask[: len(other_dps.pauli_mask)] ^= other_dps.pauli_mask
+            tweak = _vectorized_pauli_mul_phase(
+                self.pauli_mask[:min_len], other_dps.pauli_mask[:min_len]
+            )
             return concrete_class(
-                pauli_mask=mask,
-                coefficient=self.coefficient * _vectorized_pauli_mul_phase(self.pauli_mask[i], p),
+                pauli_mask=new_mask, coefficient=self.coefficient * other_dps.coefficient * tweak
             )
 
         return NotImplemented
@@ -284,15 +264,8 @@ class BaseDensePauliString(raw_types.Gate, metaclass=abc.ABCMeta):
         if isinstance(other, (sympy.Basic, numbers.Number)):
             return self.__mul__(other)
 
-        split = _attempt_value_to_pauli_index(other)
-        if split is not None:
-            p, i = split
-            mask = np.copy(self.pauli_mask)
-            mask[i] ^= p
-            return type(self)(
-                pauli_mask=mask,
-                coefficient=self.coefficient * _vectorized_pauli_mul_phase(p, self.pauli_mask[i]),
-            )
+        if other := _try_interpret_as_dps(other):
+            return other.__mul__(self)
 
         return NotImplemented
 
@@ -369,18 +342,11 @@ class BaseDensePauliString(raw_types.Gate, metaclass=abc.ABCMeta):
         )
 
     def _commutes_(self, other: Any, *, atol: float = 1e-8) -> bool | NotImplementedType | None:
-        if isinstance(other, BaseDensePauliString):
-            n = min(len(self.pauli_mask), len(other.pauli_mask))
-            phase = _vectorized_pauli_mul_phase(self.pauli_mask[:n], other.pauli_mask[:n])
+        if (other_dps := _try_interpret_as_dps(other)) is not None:
+            n = min(len(self.pauli_mask), len(other_dps.pauli_mask))
+            phase = _vectorized_pauli_mul_phase(self.pauli_mask[:n], other_dps.pauli_mask[:n])
             return phase == 1 or phase == -1
 
-        # Single qubit Pauli operation.
-        split = _attempt_value_to_pauli_index(other)
-        if split is not None:
-            p1, i = split
-            p2 = self.pauli_mask[i]
-            return (p1 or p2) == (p2 or p1)
-
         return NotImplemented
 
     def frozen(self) -> DensePauliString:
@@ -518,20 +484,6 @@ class MutableDensePauliString(BaseDensePauliString):
         return NotImplemented
 
     def __imul__(self, other):
-        if isinstance(other, BaseDensePauliString):
-            if len(other) > len(self):
-                raise ValueError(
-                    "The receiving dense pauli string is smaller than "
-                    "the dense pauli string being multiplied into it.\n"
-                    f"self={repr(self)}\n"
-                    f"other={repr(other)}"
-                )
-            self_mask = self.pauli_mask[: len(other.pauli_mask)]
-            self._coefficient *= _vectorized_pauli_mul_phase(self_mask, other.pauli_mask)
-            self._coefficient *= other.coefficient
-            self_mask ^= other.pauli_mask
-            return self
-
         if isinstance(other, (sympy.Basic, numbers.Number)):
             new_coef = protocols.mul(self.coefficient, other, default=None)
             if new_coef is None:
@@ -539,11 +491,18 @@ class MutableDensePauliString(BaseDensePauliString):
             self._coefficient = new_coef if isinstance(new_coef, sympy.Basic) else complex(new_coef)
             return self
 
-        split = _attempt_value_to_pauli_index(other)
-        if split is not None:
-            p, i = split
-            self._coefficient *= _vectorized_pauli_mul_phase(self.pauli_mask[i], p)
-            self.pauli_mask[i] ^= p
+        if (other_dps := _try_interpret_as_dps(other)) is not None:
+            if len(other_dps) > len(self):
+                raise ValueError(
+                    "The receiving dense pauli string is smaller than "
+                    "the dense pauli string being multiplied into it.\n"
+                    f"self={repr(self)}\n"
+                    f"other={repr(other)}"
+                )
+            self_mask = self.pauli_mask[: len(other_dps.pauli_mask)]
+            self._coefficient *= _vectorized_pauli_mul_phase(self_mask, other_dps.pauli_mask)
+            self._coefficient *= other_dps.coefficient
+            self_mask ^= other_dps.pauli_mask
             return self
 
         return NotImplemented
@@ -613,23 +572,27 @@ def _as_pauli_mask(val: Iterable[cirq.PAULI_GATE_LIKE] | np.ndarray) -> np.ndarr
     return np.array([_pauli_index(v) for v in val], dtype=np.uint8)
 
 
-def _attempt_value_to_pauli_index(v: cirq.Operation) -> tuple[int, int] | None:
-    if not isinstance(v, raw_types.Operation):
-        return None
+def _try_interpret_as_dps(v: cirq.Operation) -> BaseDensePauliString | None:
+    if isinstance(v, BaseDensePauliString):
+        return v
 
-    if not isinstance(v.gate, pauli_gates.Pauli):
-        return None  # pragma: no cover
+    if (ps := pauli_string._try_interpret_as_pauli_string(v)) is None:
+        return None
 
-    q = v.qubits[0]
     from cirq import devices
 
-    if not isinstance(q, devices.LineQubit):
+    if not all(isinstance(q, devices.LineQubit) for q in ps.qubits):
         raise ValueError(
             'Got a Pauli operation, but it was applied to a qubit type '
             'other than `cirq.LineQubit` so its dense index is ambiguous.\n'
             f'v={repr(v)}.'
         )
-    return pauli_string.PAULI_GATE_LIKE_TO_INDEX_MAP[v.gate], q.x
+
+    pauli_mask = np.zeros(max((q.x + 1 for q in ps.qubits), default=0), dtype=np.uint8)
+    for q in ps.qubits:
+        pauli_mask[q.x] = pauli_string.PAULI_GATE_LIKE_TO_INDEX_MAP[ps[q]]
+
+    return DensePauliString(pauli_mask)
 
 
 def _vectorized_pauli_mul_phase(lhs: int | np.ndarray, rhs: int | np.ndarray) -> complex:

cirq/ops/dense_pauli_string_test.py

@@ -173,6 +173,10 @@ def test_mul() -> None:
     with pytest.raises(ValueError, match='other than `cirq.LineQubit'):
         _ = f('III') * cirq.X(cirq.NamedQubit('tmp'))
 
+    # Parity operations.
+    assert f('IXYZ') * cirq.XX(*cirq.LineQubit.range(1, 3)) == -1j * f('IIZZ')
+    assert cirq.XX(*cirq.LineQubit.range(1, 3)) * f('IXYZ') == 1j * f('IIZZ')
+
     # Mixed types.
     m = cirq.MutableDensePauliString
     assert m('X') * m('Z') == -1j * m('Y')
@@ -187,6 +191,10 @@ def test_mul() -> None:
     assert f('I') * f('III') == f('III')
     assert f('X') * f('XXX') == f('IXX')
     assert f('XXX') * f('X') == f('IXX')
+    assert f('X') * cirq.Y(cirq.LineQubit(2)) == f('XIY')
+    assert f('XY') * cirq.YY(*cirq.LineQubit.range(1, 3)) == f('XIY')
+    assert cirq.X(cirq.LineQubit(2)) * f('Y') == f('YIX')
+    assert cirq.XX(*cirq.LineQubit.range(1, 3)) * f('YX') == f('YIX')
 
     with pytest.raises(TypeError):
         _ = f('I') * object()
@@ -235,8 +243,15 @@ def test_imul() -> None:
     p *= cirq.X(cirq.LineQubit(1))
     assert p == m('IZI')
 
+    p *= cirq.ZZ(*cirq.LineQubit.range(1, 3))
+    assert p == m('IIZ')
+
     with pytest.raises(ValueError, match='smaller than'):
         p *= f('XXXXXXXXXXXX')
+    with pytest.raises(ValueError, match='smaller than'):
+        p *= cirq.X(cirq.LineQubit(3))
+    with pytest.raises(ValueError, match='smaller than'):
+        p *= cirq.XX(*cirq.LineQubit.range(2, 4))
     with pytest.raises(TypeError):
         p *= object()
 
@@ -507,6 +522,12 @@ def test_commutes() -> None:
     assert cirq.commutes(f('IIIXII'), cirq.X(cirq.LineQubit(2)))
     assert not cirq.commutes(f('IIIXII'), cirq.Z(cirq.LineQubit(3)))
     assert cirq.commutes(f('IIIXII'), cirq.Z(cirq.LineQubit(2)))
+    assert cirq.commutes(f('IIIXII'), cirq.X(cirq.LineQubit(3)) ** 3)
+    assert cirq.commutes(f('IIIXII'), cirq.X(cirq.LineQubit(2)) ** 3)
+    assert not cirq.commutes(f('IIIXII'), cirq.Z(cirq.LineQubit(3)) ** 3)
+    assert cirq.commutes(f('IIIXII'), cirq.Z(cirq.LineQubit(2)) ** 3)
+    assert cirq.commutes(f('X'), cirq.Z(cirq.LineQubit(10)))
+    assert cirq.commutes(cirq.Z(cirq.LineQubit(10)), f('X'))
 
     assert cirq.commutes(f('XX'), "test", default=NotImplemented) is NotImplemented
 

cirq/ops/diagonal_gate.py

@@ -20,7 +20,8 @@ passed as a list.
 
 from __future__ import annotations
 
-from typing import AbstractSet, Any, Iterator, Sequence, TYPE_CHECKING
+from collections.abc import Iterator, Sequence, Set
+from typing import Any, TYPE_CHECKING
 
 import numpy as np
 import sympy
@@ -95,7 +96,7 @@ class DiagonalGate(raw_types.Gate):
     def _is_parameterized_(self) -> bool:
         return any(protocols.is_parameterized(angle) for angle in self._diag_angles_radians)
 
-    def _parameter_names_(self) -> AbstractSet[str]:
+    def _parameter_names_(self) -> Set[str]:
         return {
             name for angle in self._diag_angles_radians for name in protocols.parameter_names(angle)
         }

cirq/ops/eigen_gate.py

@@ -18,8 +18,9 @@ import abc
 import fractions
 import math
 import numbers
+from collections.abc import Iterable, Set
 from types import NotImplementedType
-from typing import AbstractSet, Any, cast, Iterable, NamedTuple, TYPE_CHECKING
+from typing import Any, cast, NamedTuple, TYPE_CHECKING
 
 import numpy as np
 import sympy
@@ -341,16 +342,17 @@ class EigenGate(raw_types.Gate):
     def _is_parameterized_(self) -> bool:
         return protocols.is_parameterized(self._exponent)
 
-    def _parameter_names_(self) -> AbstractSet[str]:
+    def _parameter_names_(self) -> Set[str]:
         return protocols.parameter_names(self._exponent)
 
     def _resolve_parameters_(self, resolver: cirq.ParamResolver, recursive: bool) -> EigenGate:
         exponent = resolver.value_of(self._exponent, recursive)
-        if isinstance(exponent, numbers.Complex):
-            if isinstance(exponent, numbers.Real):
-                exponent = float(exponent)
-            else:
-                raise ValueError(f'Complex exponent {exponent} not supported for EigenGate')
+        # Note that int/float checking is purposely done first,
+        # since numbers instance checking is somewhat slow.
+        if isinstance(exponent, (int, float)) or isinstance(exponent, numbers.Real):  # noqa: SIM101
+            exponent = float(exponent)
+        elif isinstance(exponent, numbers.Complex):
+            raise ValueError(f'Complex exponent {exponent} not supported for EigenGate')
         return self._with_exponent(exponent=exponent)
 
     def _equal_up_to_global_phase_(self, other, atol):

cirq/ops/fourier_transform.py

@@ -14,7 +14,8 @@
 
 from __future__ import annotations
 
-from typing import AbstractSet, Any
+from collections.abc import Set
+from typing import Any
 
 import numpy as np
 import sympy
@@ -163,7 +164,7 @@ class PhaseGradientGate(raw_types.Gate):
     def _is_parameterized_(self) -> bool:
         return cirq.is_parameterized(self.exponent)
 
-    def _parameter_names_(self) -> AbstractSet[str]:
+    def _parameter_names_(self) -> Set[str]:
         return cirq.parameter_names(self.exponent)
 
     def _resolve_parameters_(

cirq/ops/fourier_transform_test.py

@@ -107,9 +107,7 @@ def test_qft() -> None:
 
     arr = np.array([[1, 1, 1, 1], [1, -1j, -1, 1j], [1, -1, 1, -1], [1, 1j, -1, -1j]]) / 2
     np.testing.assert_allclose(
-        cirq.unitary(cirq.qft(*cirq.LineQubit.range(2)) ** -1),  # type: ignore[operator]
-        arr,  # type: ignore[arg-type]
-        atol=1e-8,
+        cirq.unitary(cirq.qft(*cirq.LineQubit.range(2)) ** -1), arr, atol=1e-8
     )
 
     for k in range(4):
@@ -121,7 +119,7 @@ def test_qft() -> None:
 
 def test_inverse() -> None:
     a, b, c = cirq.LineQubit.range(3)
-    assert cirq.qft(a, b, c, inverse=True) == cirq.qft(a, b, c) ** -1  # type: ignore[operator]
+    assert cirq.qft(a, b, c, inverse=True) == cirq.qft(a, b, c) ** -1
     assert cirq.qft(a, b, c, inverse=True, without_reverse=True) == cirq.inverse(
         cirq.qft(a, b, c, without_reverse=True)
     )

cirq/ops/fsim_gate.py

@@ -26,7 +26,8 @@ from __future__ import annotations
 
 import cmath
 import math
-from typing import AbstractSet, Any, Iterator
+from collections.abc import Iterator, Set
+from typing import Any
 
 import numpy as np
 import sympy
@@ -125,7 +126,7 @@ class FSimGate(gate_features.InterchangeableQubitsGate, raw_types.Gate):
     def _is_parameterized_(self) -> bool:
         return cirq.is_parameterized(self.theta) or cirq.is_parameterized(self.phi)
 
-    def _parameter_names_(self) -> AbstractSet[str]:
+    def _parameter_names_(self) -> Set[str]:
         return cirq.parameter_names(self.theta) | cirq.parameter_names(self.phi)
 
     def _has_unitary_(self):

cirq/ops/gate_operation.py

@@ -16,20 +16,12 @@
 
 from __future__ import annotations
 
+import numbers
 import re
 import warnings
+from collections.abc import Collection, Mapping, Sequence, Set
 from types import NotImplementedType
-from typing import (
-    AbstractSet,
-    Any,
-    cast,
-    Collection,
-    Mapping,
-    Self,
-    Sequence,
-    TYPE_CHECKING,
-    TypeVar,
-)
+from typing import Any, cast, Self, TYPE_CHECKING, TypeVar
 
 from cirq import ops, protocols, value
 from cirq.ops import control_values as cv, gate_features, raw_types
@@ -269,7 +261,7 @@ class GateOperation(raw_types.Operation):
             return getter()
         return NotImplemented
 
-    def _parameter_names_(self) -> AbstractSet[str]:
+    def _parameter_names_(self) -> Set[str]:
         getter = getattr(self.gate, '_parameter_names_', None)
         if getter is not None:
             return getter()
@@ -331,6 +323,25 @@ class GateOperation(raw_types.Operation):
     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):
+        return other + -self
+
+    def __neg__(self):
+        return -1 * self
+
     def _qasm_(self, args: protocols.QasmArgs) -> str | None:
         if isinstance(self.gate, ops.GlobalPhaseGate):
             warnings.warn(

cirq/ops/gateset.py

@@ -16,7 +16,8 @@
 
 from __future__ import annotations
 
-from typing import Any, Callable, cast, Hashable, Iterable, TYPE_CHECKING
+from collections.abc import Callable, Hashable, Iterable
+from typing import Any, cast, TYPE_CHECKING
 
 from cirq import protocols, value
 from cirq.ops import global_phase_op, op_tree, raw_types
@@ -340,6 +341,7 @@ class Gateset:
         self._unroll_circuit_op = unroll_circuit_op
         self._instance_gate_families: dict[raw_types.Gate, GateFamily] = {}
         self._type_gate_families: dict[type[raw_types.Gate], GateFamily] = {}
+        self._gate_families_with_tags: list[GateFamily] = []
         self._gates_repr_str = ", ".join([_gate_str(g, repr) for g in gates])
         unique_gate_list: list[GateFamily] = list(
             dict.fromkeys(g if isinstance(g, GateFamily) else GateFamily(gate=g) for g in gates)
@@ -351,6 +353,12 @@ class Gateset:
                     self._instance_gate_families[g.gate] = g
                 else:
                     self._type_gate_families[g.gate] = g
+            else:
+                if isinstance(g.gate, raw_types.Gate):
+                    self._gate_families_with_tags.append(g)
+                else:
+                    # Instance checks are faster, so test them first.
+                    self._gate_families_with_tags.insert(0, g)
         self._unique_gate_list = unique_gate_list
         self._gates = frozenset(unique_gate_list)
 
@@ -422,6 +430,7 @@ class Gateset:
         g = item if isinstance(item, raw_types.Gate) else item.gate
         assert g is not None, f'`item`: {item} must be a gate or have a valid `item.gate`'
 
+        # Check "type" based GateFamily since isinstance is fast
         for gate_mro_type in type(g).mro():
             if gate_mro_type in self._type_gate_families:
                 assert item in self._type_gate_families[gate_mro_type], (
@@ -430,6 +439,7 @@ class Gateset:
                 )
                 return True
 
+        # Check exact instance equality next
         if g in self._instance_gate_families:
             assert item in self._instance_gate_families[g], (
                 f"{item} instance matches {self._instance_gate_families[g]} but "
@@ -437,7 +447,17 @@ class Gateset:
             )
             return True
 
-        return any(item in gate_family for gate_family in self._gates)
+        # Check other GateFamilies next
+        if any(item in gate_family for gate_family in self._gate_families_with_tags):
+            return True
+
+        # Lastly, do a final exhaustive check to make sure this is not equivalent
+        # to another type of gate. This will catch things like:
+        # cirq.XPowGate(exponent=0) in cirq.GateFamily(cirq.I)
+        return any(
+            item in gate_family
+            for gate_family in self._gates.difference(self._gate_families_with_tags)
+        )
 
     def validate(self, circuit_or_optree: cirq.AbstractCircuit | op_tree.OP_TREE) -> bool:
         """Validates gates forming `circuit_or_optree` should be contained in Gateset.

cirq/ops/global_phase_op.py

@@ -15,8 +15,9 @@
 
 from __future__ import annotations
 
+from collections.abc import Collection, Sequence, Set
 from types import NotImplementedType
-from typing import AbstractSet, Any, cast, Collection, Sequence
+from typing import Any, cast
 
 import numpy as np
 import sympy
@@ -83,7 +84,7 @@ class GlobalPhaseGate(raw_types.Gate):
     def _is_parameterized_(self) -> bool:
         return protocols.is_parameterized(self.coefficient)
 
-    def _parameter_names_(self) -> AbstractSet[str]:
+    def _parameter_names_(self) -> Set[str]:
         return protocols.parameter_names(self.coefficient)
 
     def _resolve_parameters_(

cirq/ops/greedy_qubit_manager.py

@@ -14,7 +14,8 @@
 
 from __future__ import annotations
 
-from typing import Iterable, TYPE_CHECKING
+from collections.abc import Iterable
+from typing import TYPE_CHECKING
 
 from cirq.ops import named_qubit, qid_util, qubit_manager
 

cirq/ops/identity.py

@@ -16,8 +16,9 @@
 from __future__ import annotations
 
 import numbers
+from collections.abc import Sequence
 from types import NotImplementedType
-from typing import Any, Sequence, TYPE_CHECKING
+from typing import Any, TYPE_CHECKING
 
 import numpy as np
 import sympy

cirq/ops/kraus_channel.py

@@ -2,7 +2,8 @@
 
 from __future__ import annotations
 
-from typing import Any, Iterable, Mapping, TYPE_CHECKING
+from collections.abc import Iterable, Mapping
+from typing import Any, TYPE_CHECKING
 
 import numpy as np
 

cirq/ops/linear_combinations.py

@@ -16,7 +16,8 @@ from __future__ import annotations
 
 import numbers
 from collections import defaultdict
-from typing import AbstractSet, Any, Iterable, Mapping, TYPE_CHECKING, Union
+from collections.abc import Iterable, Mapping, Set
+from typing import Any, TYPE_CHECKING, Union
 
 import numpy as np
 import sympy
@@ -136,7 +137,7 @@ class LinearCombinationOfGates(value.LinearDict[raw_types.Gate]):
     def _is_parameterized_(self) -> bool:
         return any(protocols.is_parameterized(item) for item in self.items())
 
-    def _parameter_names_(self) -> AbstractSet[str]:
+    def _parameter_names_(self) -> Set[str]:
         return {name for item in self.items() for name in protocols.parameter_names(item)}
 
     def _resolve_parameters_(
@@ -253,7 +254,7 @@ class LinearCombinationOfOperations(value.LinearDict[raw_types.Operation]):
     def _is_parameterized_(self) -> bool:
         return any(protocols.is_parameterized(item) for item in self.items())
 
-    def _parameter_names_(self) -> AbstractSet[str]:
+    def _parameter_names_(self) -> Set[str]:
         return {name for item in self.items() for name in protocols.parameter_names(item)}
 
     def _resolve_parameters_(
@@ -742,14 +743,12 @@ class PauliSum:
         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):
             other = PauliSum.from_pauli_strings([other])
-        elif isinstance(other, raw_types.Operation) and isinstance(
-            other.gate, identity.IdentityGate
-        ):
-            other = PauliSum.from_pauli_strings([PauliString()])
 
         if not isinstance(other, PauliSum):
             return NotImplemented
@@ -758,10 +757,9 @@ class PauliSum:
         return self
 
     def __add__(self, other):
-        if not isinstance(other, (numbers.Complex, PauliString, PauliSum, raw_types.Operation)):
-            return NotImplemented
         result = self.copy()
-        result += other
+        if result.__iadd__(other) is NotImplemented:
+            return NotImplemented
         return result
 
     def __radd__(self, other):
@@ -771,14 +769,12 @@ class PauliSum:
         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):
             other = PauliSum.from_pauli_strings([other])
-        elif isinstance(other, raw_types.Operation) and isinstance(
-            other.gate, identity.IdentityGate
-        ):
-            other = PauliSum.from_pauli_strings([PauliString()])
 
         if not isinstance(other, PauliSum):
             return NotImplemented
@@ -787,10 +783,9 @@ class PauliSum:
         return self
 
     def __sub__(self, other):
-        if not isinstance(other, (numbers.Complex, PauliString, PauliSum, raw_types.Operation)):
-            return NotImplemented
         result = self.copy()
-        result -= other
+        if result.__isub__(other) is NotImplemented:
+            return NotImplemented
         return result
 
     def __neg__(self):