Fix bug where unexpected queuing occurs in qml.ctrl among other functions

doc/releases/changelog-dev.md

@@ -174,6 +174,9 @@
 * Fixes a bug where a simple circuit with no parameters or only builtin/numpy arrays as parameters returns autograd tensors.
   [(#6225)](https://github.com/PennyLaneAI/pennylane/pull/6225)
 
+* Fixes a bug where `qml.ctrl` and `qml.adjoint` queued extra operators if they were defined as the arguments.
+  [(#6284)](https://github.com/PennyLaneAI/pennylane/pull/6284)
+
 <h3>Contributors ✍️</h3>
 
 This release contains contributions from (in alphabetical order):

pennylane/ops/op_math/adjoint.py

@@ -22,6 +22,7 @@
 from pennylane.compiler import compiler
 from pennylane.math import conj, moveaxis, transpose
 from pennylane.operation import Observable, Operation, Operator
+from pennylane.ops.op_math.controlled import remove_from_queue_args_and_kwargs
 from pennylane.queuing import QueuingManager
 from pennylane.tape import make_qscript
 
@@ -236,6 +237,13 @@ def _adjoint_transform(qfunc: Callable, lazy=True) -> Callable:
     @wraps(qfunc)
     def wrapper(*args, **kwargs):
         qscript = make_qscript(qfunc)(*args, **kwargs)
+
+        for arg in args:
+            remove_from_queue_args_and_kwargs(arg)
+
+        for value in kwargs.values():
+            remove_from_queue_args_and_kwargs(value)
+
         if lazy:
             adjoint_ops = [Adjoint(op) for op in reversed(qscript.operations)]
         else:

pennylane/ops/op_math/controlled.py

@@ -199,11 +199,29 @@ def create_controlled_op(op, control, control_values=None, work_wires=None):
     return _ctrl_transform(op, control, control_values, work_wires)
 
 
+def remove_from_queue_args_and_kwargs(item):
+    """function used to recursively remove operators that have been added to the queue in an argument or kwarg."""
+    if isinstance(item, (list, tuple, set)):
+        for elem in item:
+            remove_from_queue_args_and_kwargs(elem)
+    elif isinstance(item, dict):
+        for value in item.values():
+            remove_from_queue_args_and_kwargs(value)
+    elif isinstance(item, Operator):
+        qml.queuing.QueuingManager.remove(item)
+
+
 def _ctrl_transform(op, control, control_values, work_wires):
     @wraps(op)
     def wrapper(*args, **kwargs):
         qscript = qml.tape.make_qscript(op)(*args, **kwargs)
 
+        for arg in args:
+            remove_from_queue_args_and_kwargs(arg)
+
+        for value in kwargs.values():
+            remove_from_queue_args_and_kwargs(value)
+
         # flip control_values == 0 wires here, so we don't have to do it for each individual op.
         flip_control_on_zero = (len(qscript) > 1) and (control_values is not None)
         op_control_values = None if flip_control_on_zero else control_values

pennylane/ops/op_math/prod.py

@@ -111,6 +111,7 @@ def prod(*ops, id=None, lazy=True):
         @wraps(fn)
         def wrapper(*args, **kwargs):
             qs = qml.tape.make_qscript(fn)(*args, **kwargs)
+
             if len(qs.operations) == 1:
                 if qml.QueuingManager.recording():
                     qml.apply(qs[0])

tests/ops/op_math/test_adjoint.py

@@ -868,6 +868,21 @@ def test_single_op_defined_outside_queue_eager(self):
         assert len(q) == 1
         assert q.queue[0] is out
 
+    def test_correct_queued_operators(self):
+        """Test that args and kwargs do not add operators to the queue."""
+
+        dev = qml.device("default.qubit")
+
+        @qml.qnode(dev)
+        def circuit():
+            qml.adjoint(qml.QSVT)(qml.X(1), [qml.Z(1)])
+            qml.adjoint(qml.QSVT(qml.X(1), [qml.Z(1)]))
+            return qml.state()
+
+        circuit()
+        for op in circuit.tape.operations:
+            assert op.name == "Adjoint(QSVT)"
+
     @pytest.mark.usefixtures("use_legacy_opmath")
     def test_single_observable(self):
         """Test passing a single preconstructed observable in a queuing context."""

tests/ops/op_math/test_controlled.py

@@ -1899,6 +1899,23 @@ def test_nested_pauli_x_based_ctrl_ops(self):
         expected = qml.MultiControlledX(wires=[3, 2, 1, 0], control_values=[1, 0, 1])
         assert op == expected
 
+    def test_correct_queued_operators(self):
+        """Test that args and kwargs do not add operators to the queue."""
+
+        def func(dic):
+            for gate in dic.values():
+                qml.apply(gate)
+
+        dev = qml.device("default.qubit")
+
+        @qml.qnode(dev)
+        def circuit():
+            qml.ctrl(func, control=0)({1: qml.X(1), 2: qml.Z(1)})
+            return qml.state()
+
+        circuit()
+        assert len(circuit.tape.operations) == 2
+
 
 class _Rot(Operation):
     """A rotation operation that is not an instance of Rot

tests/ops/op_math/test_prod.py

@@ -1425,6 +1425,21 @@ def test_nonlazy_mode_queueing(self):
         assert len(q) == 1
         assert q.queue[0] is prod2
 
+    def test_correct_queued_operators(self):
+        """Test that args and kwargs do not add operators to the queue."""
+
+        dev = qml.device("default.qubit")
+
+        @qml.qnode(dev)
+        def circuit():
+            qml.prod(qml.QSVT)(qml.X(1), [qml.Z(1)])
+            qml.prod(qml.QSVT(qml.X(1), [qml.Z(1)]))
+            return qml.state()
+
+        circuit()
+        for op in circuit.tape.operations:
+            assert op.name == "QSVT"
+
 
 class TestIntegration:
     """Integration tests for the Prod class."""