Modified the signature for ResourceOperator class (#8279)

**Context:**
Modified the signature for controlled decomposition of ResourceOperator
class.

**Description of the Change:**

**Benefits:**

**Possible Drawbacks:**

**Related GitHub Issues:**

---------

Co-authored-by: Soran Jahangiri <40344468+soranjh@users.noreply.github.com>
Co-authored-by: Christina Lee <christina@xanadu.ai>

Author: 3 people

doc/releases/changelog-dev.md

@@ -17,6 +17,7 @@
   * The `qml.estimator.ResourceOperator`, `qml.estimator.CompressedResourceOp`, and `qml.estimator.GateCount` classes
     were added as base classes to represent quantum operators.
     [(#8227)](https://github.com/PennyLaneAI/pennylane/pull/8227)
+    [(#8279)](https://github.com/PennyLaneAI/pennylane/pull/8279)
   * The :class:`~.estimator.Resources` class was added as a container class for resources.
     [(#8205)](https://github.com/PennyLaneAI/pennylane/pull/8205)
   * The test files were renamed to avoid the dual definition error with labs module.

pennylane/estimator/resource_operator.py

@@ -267,31 +267,45 @@ def resource_decomp(cls, *args, **kwargs) -> list[GateCount]:
         r"""Returns a list of actions that define the resources of the operator."""
 
     @classmethod
-    def adjoint_resource_decomp(cls, *args, **kwargs) -> list[GateCount]:
-        r"""Returns a list representing the resources for the adjoint of the operator."""
+    def adjoint_resource_decomp(cls, target_resource_params: dict | None = None) -> list[GateCount]:
+        r"""Returns a list representing the resources for the adjoint of the operator.
+
+        Args:
+            target_resource_params (dict | None): A dictionary containing the resource parameters
+                of the target operator.
+        """
         raise ResourcesUndefinedError
 
     @classmethod
     def controlled_resource_decomp(
-        cls, ctrl_num_ctrl_wires: int, ctrl_num_ctrl_values: int, *args, **kwargs
+        cls,
+        num_ctrl_wires: int,
+        num_zero_ctrl: int,
+        target_resource_params: dict | None = None,
     ) -> list[GateCount]:
         r"""Returns a list representing the resources for a controlled version of the operator.
 
         Args:
-            ctrl_num_ctrl_wires (int): the number of qubits the
+            num_ctrl_wires (int): the number of qubits the
                 operation is controlled on
-            ctrl_num_ctrl_values (int): the number of control qubits, that are
+            num_zero_ctrl (int): the number of control qubits, that are
                 controlled when in the :math:`|0\rangle` state
+            target_resource_params (dict | None): A dictionary containing the resource parameters
+                of the target operator.
         """
         raise ResourcesUndefinedError
 
     @classmethod
-    def pow_resource_decomp(cls, pow_z: int, *args, **kwargs) -> list[GateCount]:
+    def pow_resource_decomp(
+        cls, pow_z: int, target_resource_params: dict | None = None
+    ) -> list[GateCount]:
         r"""Returns a list representing the resources for an operator
         raised to a power.
 
         Args:
             pow_z (int): exponent that the operator is being raised to
+            target_resource_params (dict | None): A dictionary containing the resource parameters
+                of the target operator.
         """
         raise ResourcesUndefinedError
 

tests/estimator/test_estimator_resOp.py

@@ -25,7 +25,6 @@
 from pennylane.estimator import CompressedResourceOp, ResourceOperator, Resources
 from pennylane.estimator.resource_operator import (
     GateCount,
-    ResourcesUndefinedError,
     _dequeue,
     _make_hashable,
     resource_rep,
@@ -304,6 +303,67 @@ class CNOT(DummyOp):
     num_wires = 2
 
 
+class DummyOp_decomps(ResourceOperator):
+    """Class for testing the resource_decomp methods"""
+
+    resource_keys = {"max_register_size"}
+
+    def __init__(self, max_register_size, wires=None):
+        self.max_register_size = max_register_size
+        self.num_wires = 2 * max_register_size
+        super().__init__(wires=wires)
+
+    @property
+    def resource_params(self):
+        r"""Returns a dictionary containing the minimal information needed to compute the resources."""
+        return {"max_register_size": self.max_register_size}
+
+    @classmethod
+    def resource_rep(cls, max_register_size):
+        r"""Returns a compressed representation containing only the parameters of
+        the Operator that are needed to compute the resources.
+        """
+        num_wires = 2 * max_register_size
+        return CompressedResourceOp(cls, num_wires, {"max_register_size": max_register_size})
+
+    @classmethod
+    def resource_decomp(cls, max_register_size):
+        r"""Returns a dictionary representing the resources of the operator. The
+        keys are the operators and the associated values are the counts.
+        """
+        rx = resource_rep(RX, {"x": 1})
+        return [GateCount(rx, max_register_size)]
+
+    @classmethod
+    def controlled_resource_decomp(cls, num_ctrl_wires, num_zero_ctrl, target_resource_params):
+        r"""Returns a list representing the resources of the operator. Each object in the list represents a gate and the
+        number of times it occurs in the circuit.
+        """
+        max_register_size = target_resource_params["max_register_size"]
+        cnot = resource_rep(CNOT, {"x": None})
+        rx = resource_rep(RX, {"x": 1})
+        return [GateCount(cnot, max_register_size), GateCount(rx, max_register_size)]
+
+    @classmethod
+    def adjoint_resource_decomp(cls, target_resource_params):
+        r"""Returns a list representing the resources of the operator. Each object in the list represents a gate and the
+        number of times it occurs in the circuit.
+        """
+        max_register_size = target_resource_params["max_register_size"]
+        rx = resource_rep(RX, {"x": 1})
+        h = resource_rep(Hadamard, {"x": None})
+        return [GateCount(rx, max_register_size), GateCount(h, 2 * max_register_size)]
+
+    @classmethod
+    def pow_resource_decomp(cls, pow_z, target_resource_params):
+        r"""Returns a list representing the resources of the operator. Each object in the list represents a gate and the
+        number of times it occurs in the circuit.
+        """
+        max_register_size = target_resource_params["max_register_size"]
+        rx = resource_rep(RX, {"x": 1})
+        return [GateCount(rx, max_register_size * pow_z)]
+
+
 class TestResourceOperator:
     """Tests for the ResourceOperator class"""
 
@@ -485,22 +545,30 @@ def test_matmul_error(self):
     def test_default_resource_keys(self):
         """Test that default resource keys returns the correct result."""
         op1 = X
-        assert op1.resource_keys == set()
+        assert op1.resource_keys == set()  # pylint: disable=comparison-with-callable
 
     def test_adjoint_resource_decomp(self):
         """Test that default adjoint operator returns the correct error."""
-        with pytest.raises(ResourcesUndefinedError):
-            X.adjoint_resource_decomp()
+        dummy_params = {"max_register_size": 10}
+        assert DummyOp_decomps.adjoint_resource_decomp(target_resource_params=dummy_params) == [
+            GateCount(DummyCmprsRep("RX", 1), 10),
+            GateCount(DummyCmprsRep("Hadamard", None), 20),
+        ]
 
     def test_controlled_resource_decomp(self):
         """Test that default controlled operator returns the correct error."""
-        with pytest.raises(ResourcesUndefinedError):
-            X.controlled_resource_decomp(ctrl_num_ctrl_wires=2, ctrl_num_ctrl_values=0)
+        dummy_params = {"max_register_size": 10}
+        assert DummyOp_decomps.controlled_resource_decomp(
+            num_ctrl_wires=2, num_zero_ctrl=0, target_resource_params=dummy_params
+        ) == [GateCount(DummyCmprsRep("CNOT", None), 10), GateCount(DummyCmprsRep("RX", 1), 10)]
 
     def test_pow_resource_decomp(self):
         """Test that default power operator returns the correct error."""
-        with pytest.raises(ResourcesUndefinedError):
-            X.pow_resource_decomp(2)
+
+        dummy_params = {"max_register_size": 10}
+        assert DummyOp_decomps.pow_resource_decomp(
+            pow_z=2, target_resource_params=dummy_params
+        ) == [GateCount(DummyCmprsRep("RX", 1), 20)]
 
     def test_tracking_name(self):
         """Test that correct tracking name is returned."""