Stop queueing from within qml.pauli.PauliWord.operation and qml.pauli.PauliSentence.operation (#8136)

**Context:**
Queuing behaviour is inconsistent due to caching, see bug report.

**Description of the Change:**

Stop queuing altogether from within the mentioned methods.

**Benefits:**
Consistent queuing behaviour.

**Possible Drawbacks:**
Stopping the queuing system for each call to `.operation` might be a
performance regression (because in many cases there was no queuing
anyways, so now we just do extra work of toggling the recording status,
I suppose).

**Related GitHub Issues:**
Fixes #8135
[sc-98282]

Author: dwierichs

doc/releases/changelog-dev.md

@@ -501,6 +501,10 @@
 
 <h3>Breaking changes 💔</h3>
 
+* The methods :meth:`~.pauli.PauliWord.operation` and :meth:`~.pauli.PauliSentence.operation`
+  no longer queue any operators.
+  [(#8136)](https://github.com/PennyLaneAI/pennylane/pull/8136)
+
 * `qml.sample` no longer has singleton dimensions squeezed out for single shots or single wires. This cuts
   down on the complexity of post-processing due to having to handle single shot and single wire cases
   separately. The return shape will now *always* be `(shots, num_wires)`.
@@ -878,6 +882,11 @@
 
 <h3>Bug fixes 🐛</h3>
 
+* Fixes a bug that made the queueing behaviour of :meth:`~.pauli.PauliWord.operation` and
+  :meth:`~.pauli.PauliSentence.operation` dependent on the global state of a program due to
+  a caching issue.
+  [(#8135)](https://github.com/PennyLaneAI/pennylane/pull/8135)
+
 * A more informative error is raised when extremely deep circuits are attempted to be drawn.
   [(#8139)](https://github.com/PennyLaneAI/pennylane/pull/8139)
 

pennylane/pauli/pauli_arithmetic.py

@@ -22,6 +22,7 @@
 import pennylane as qml
 from pennylane import math
 from pennylane.ops import Identity, PauliX, PauliY, PauliZ, Prod, SProd, Sum
+from pennylane.queuing import QueuingManager
 from pennylane.typing import TensorLike
 from pennylane.wires import Wires, WiresLike
 
@@ -504,6 +505,7 @@ def _get_csr_indices(self, wire_order):
             current_size *= 2
         return indices
 
+    @QueuingManager.stop_recording()
     def operation(self, wire_order: WiresLike = ()):
         """Returns a native PennyLane :class:`~pennylane.operation.Operation` representing the PauliWord."""
         if len(self) == 0:
@@ -1002,6 +1004,7 @@ def _sum_different_structure_pws(indices, data):
         matrix.eliminate_zeros()
         return matrix
 
+    @QueuingManager.stop_recording()
     def operation(self, wire_order: WiresLike = ()):
         """Returns a native PennyLane :class:`~pennylane.operation.Operation` representing the PauliSentence."""
         if len(self) == 0:

tests/ops/functions/test_commutator.py

@@ -58,45 +58,54 @@ def test_alias():
 
 def test_no_recording_in_context():
     """Test that commutator is not recorded"""
-    with qml.tape.QuantumTape() as tape:
+    with qml.queuing.AnnotatedQueue() as q1:
         a = qml.PauliX(0)  # gets recorded
         b = qml.PauliY(0)  # gets recorded
         comm = qml.commutator(a, b)
 
-    with qml.tape.QuantumTape() as tape2:
+    with qml.queuing.AnnotatedQueue() as q2:
         qml.PauliX(0)
         qml.PauliY(0)
 
-    qml.assert_equal(tape, tape2)
+    expected = [qml.X(0), qml.Y(0)]
+    for op1, op2, exp_op in zip(q1.queue, q2.queue, expected, strict=True):
+        qml.assert_equal(op1, exp_op)
+        qml.assert_equal(op2, exp_op)
 
 
 def test_no_recording_in_context_with_pauli():
     """Test that commutator is not recorded while one of the ops is a Pauli"""
-    with qml.tape.QuantumTape() as tape:
+    with qml.queuing.AnnotatedQueue() as q1:
         a = qml.PauliX(0)  # gets recorded
         b = PauliWord({0: "Y"})  # does not get recorded
         comm = qml.commutator(a, b)
 
-    with qml.tape.QuantumTape() as tape2:
+    with qml.queuing.AnnotatedQueue() as q2:
         qml.PauliX(0)
 
-    qml.assert_equal(tape, tape2)
+    expected = [qml.X(0)]
+    for op1, op2, exp_op in zip(q1.queue, q2.queue, expected, strict=True):
+        qml.assert_equal(op1, exp_op)
+        qml.assert_equal(op2, exp_op)
 
 
 def test_recording_wanted():
     """Test that commutator can be correctly recorded with qml.apply still"""
-    with qml.tape.QuantumTape() as tape:
+    with qml.queuing.AnnotatedQueue() as q1:
         a = qml.PauliX(0)
         b = qml.PauliY(0)
         comm = qml.commutator(a, b)
         qml.apply(comm)
 
-    with qml.tape.QuantumTape() as tape2:
+    with qml.queuing.AnnotatedQueue() as q2:
         qml.PauliX(0)
         qml.PauliY(0)
         qml.s_prod(2j, qml.PauliZ(0))
 
-    qml.assert_equal(tape, tape2)
+    expected = [qml.X(0), qml.Y(0), 2j * qml.Z(0)]
+    for op1, op2, exp_op in zip(q1.queue, q2.queue, expected, strict=True):
+        qml.assert_equal(op1, exp_op)
+        qml.assert_equal(op2, exp_op)
 
 
 class TestcommPauli:

tests/pauli/test_pauli_arithmetic.py

@@ -393,7 +393,10 @@ def test_to_mat_format(self, pw, wire_order, true_matrix):
     @pytest.mark.parametrize("pw, op", tup_pw_operation)
     def test_operation(self, pw, op):
         """Test that a PauliWord can be cast to a PL operation."""
-        pw_op = pw.operation()
+        with qml.queuing.AnnotatedQueue() as q:
+            pw_op = pw.operation()
+        assert len(q.queue) == 0
+
         if len(pw) > 1:
             for pw_factor, op_factor in zip(pw_op.operands, op.operands):
                 assert pw_factor.name == op_factor.name
@@ -404,14 +407,18 @@ def test_operation(self, pw, op):
 
     def test_operation_empty(self):
         """Test that an empty PauliWord with wire_order returns Identity."""
-        op = PauliWord({}).operation(wire_order=[0, 1])
+        with qml.queuing.AnnotatedQueue() as q:
+            op = PauliWord({}).operation(wire_order=[0, 1])
+        assert len(q.queue) == 0
         id = qml.Identity(wires=[0, 1])
         assert op.name == id.name
         assert op.wires == id.wires
 
     def test_operation_empty_nowires(self):
         """Test that an empty PauliWord is cast to qml.Identity() operation."""
-        res = pw4.operation()
+        with qml.queuing.AnnotatedQueue() as q:
+            res = pw4.operation()
+        assert len(q.queue) == 0
         assert res == qml.Identity()
 
     def test_pickling(self):
@@ -888,7 +895,9 @@ def _compare_ops(op1, op2):
             assert op1.name == op2.name
             assert op1.wires == op2.wires
 
-        ps_op = ps.operation()
+        with qml.queuing.AnnotatedQueue() as q:
+            ps_op = ps.operation()
+        assert len(q.queue) == 0
         if len(ps) > 1:
             for ps_summand, op_summand in zip(ps_op.operands, op.operands):
                 assert ps_summand.scalar == op_summand.scalar
@@ -902,7 +911,9 @@ def _compare_ops(op1, op2):
     def test_operation_with_identity(self):
         """Test that a PauliSentence with an empty PauliWord can be cast to
         operation correctly."""
-        full_ps_op = ps3.operation()
+        with qml.queuing.AnnotatedQueue() as q:
+            full_ps_op = ps3.operation()
+        assert len(q.queue) == 0
         full_op = qml.sum(
             -0.5 * qml.prod(qml.PauliZ(wires=0), qml.PauliZ(wires="b"), qml.PauliZ(wires="c")),
             qml.s_prod(1, qml.Identity(wires=[0, "b", "c"])),
@@ -924,7 +935,9 @@ def test_operation_with_identity(self):
 
     def test_operation_empty(self):
         """Test that an empty PauliSentence with wire_order returns Identity."""
-        op = ps5.operation(wire_order=[0, 1])
+        with qml.queuing.AnnotatedQueue() as q:
+            op = ps5.operation(wire_order=[0, 1])
+        assert len(q.queue) == 0
         id = qml.s_prod(0.0, qml.Identity(wires=[0, 1]))
 
         assert op.name == id.name
@@ -933,9 +946,14 @@ def test_operation_empty(self):
     def test_operation_empty_nowires(self):
         """Test that a ValueError is raised if an empty PauliSentence is
         cast to a PL operation."""
-        res1 = ps4.operation()
+        with qml.queuing.AnnotatedQueue() as q:
+            res1 = ps4.operation()
+        assert len(q.queue) == 0
         assert res1 == qml.Identity()
-        res2 = ps5.operation()
+
+        with qml.queuing.AnnotatedQueue() as q:
+            res2 = ps5.operation()
+        assert len(q.queue) == 0
         assert res2 == qml.s_prod(0, qml.Identity())
 
     def test_operation_wire_order(self):