matrix and cond now dequeues operators in arguments to the qfunc (#8119)

**Context:**
Applying the same thing in
#8094 to `matrix` and
`cond`

**Description of the Change:**

**Benefits:**

**Possible Drawbacks:**

**Related GitHub Issues:**
[sc-98196]

---------

Co-authored-by: Yushao Chen (Jerry) <[email protected]>

Author: astralcai

doc/releases/changelog-dev.md

@@ -871,8 +871,9 @@
 * Fixes `SemiAdder` to work when inputs are defined with a single wire.
   [(#7940)](https://github.com/PennyLaneAI/pennylane/pull/7940)
 
-* Fixes a bug where `qml.prod` applied on a quantum function does not dequeue operators passed as arguments to the function.
+* Fixes a bug where `qml.prod`, `qml.matrix`, and `qml.cond` applied on a quantum function does not dequeue operators passed as arguments to the function.
   [(#8094)](https://github.com/PennyLaneAI/pennylane/pull/8094)
+  [(#8119)](https://github.com/PennyLaneAI/pennylane/pull/8119)
 
 <h3>Contributors ✍️</h3>
 

pennylane/ops/functions/matrix.py

@@ -230,6 +230,7 @@ def circuit():
             f"Wires in circuit {list(op.wires)} are inconsistent with "
             f"those in wire_order {list(wire_order)}"
         )
+    QueuingManager.remove(op)
     if op.has_matrix:
         return op.matrix(wire_order=wire_order)
     if op.has_sparse_matrix:
@@ -263,6 +264,9 @@ def processing_fn(res):
         params = res[0].get_parameters(trainable_only=False)
         interface = qml.math.get_interface(*params)
 
+        for op in res[0].operations:
+            QueuingManager.remove(op)
+
         # initialize the unitary matrix
         if len(res[0].operations) == 0:
             result = qml.math.eye(2 ** len(wire_order), like=interface)

pennylane/ops/op_math/condition.py

@@ -253,12 +253,18 @@ def elifs(self):
         return list(zip(self.preds[1:], self.branch_fns[1:]))
 
     def __call_capture_disabled(self, *args, **kwargs):
+
+        # dequeue operators passed to args
+        leaves, _ = qml.pytrees.flatten((args, kwargs), lambda obj: isinstance(obj, Operator))
+        for l in leaves:
+            if isinstance(l, Operator):
+                qml.QueuingManager.remove(l)
+
         # python fallback
         for pred, branch_fn in zip(self.preds, self.branch_fns):
             if pred:
                 return branch_fn(*args, **kwargs)
-        # TODO: Remove when PL supports pylint==3.3.6 (it is considered a useless-suppression) [sc-91362]
-        # pylint: disable=not-callable
+
         return self.false_fn(*args, **kwargs)
 
     def __call_capture_enabled(self, *args, **kwargs):

tests/ops/functions/test_matrix.py

@@ -238,6 +238,16 @@ def node():
         ]
         assert all(np.allclose(mat, np.eye(4)) for mat in mats)
 
+    def test_matrix_dequeues_operation(self):
+        """Tests that the operator is dequeued."""
+
+        with qml.queuing.AnnotatedQueue() as q:
+            mat = qml.matrix(qml.X(0))
+            qml.QubitUnitary(mat, wires=[0])
+
+        assert len(q.queue) == 1
+        assert isinstance(q.queue[0], qml.QubitUnitary)
+
 
 class TestMultipleOperations:
     def test_multiple_operations_tape(self):
@@ -274,6 +284,21 @@ def testcircuit():
         expected_matrix = I_CNOT @ X_S_H
         assert np.allclose(matrix, expected_matrix)
 
+    def test_qfunc_arguments_dequeued(self):
+        """Tests that operators passed as arguments to the qfunc are dequeued"""
+
+        def func(op, op1=None):
+            qml.apply(op)
+            if op1:
+                qml.apply(op1)
+
+        with qml.queuing.AnnotatedQueue() as q:
+            mat = qml.matrix(func, wire_order=[0])(qml.X(0), op1=qml.Z(0))
+            qml.QubitUnitary(mat, wires=[0])
+
+        assert len(q.queue) == 1
+        assert isinstance(q.queue[0], qml.QubitUnitary)
+
     def test_multiple_operations_qnode(self):
         """Check the total matrix for a QNode containing multiple gates"""
         dev = qml.device("default.qubit", wires=["a", "b", "c"])

tests/ops/op_math/test_condition.py

@@ -251,6 +251,25 @@ def test_data_set_correctly(self, op):
         assert cond_op.num_params == op.num_params
         assert cond_op.ndim_params == op.ndim_params
 
+    def test_qfunc_arg_dequeued(self):
+        """Tests that the operators in the quantum function arguments are dequeued."""
+
+        def true_fn(op):
+            qml.apply(op)
+
+        def false_fn(op):
+            qml.apply(op)
+
+        def circuit(x):
+            qml.cond(x > 0, true_fn, false_fn)(qml.X(0))
+
+        with qml.queuing.AnnotatedQueue() as q:
+            circuit(1)
+            circuit(-1)
+
+        assert len(q.queue) == 2
+        assert q.queue == [qml.X(0), qml.X(0)]
+
 
 @pytest.mark.parametrize("op_class", [qml.PauliY, qml.Toffoli, qml.Hadamard, qml.CZ])
 def test_conditional_label(op_class):