Resource operators for Adjoint, Controlled, and Pow

pennylane/labs/resource_estimation/__init__.py

@@ -63,12 +63,15 @@
 
 """
 
-from .resource_operator import ResourceOperator, ResourcesNotDefined
+from .resource_operator import ResourceOperator, ResourcesNotDefined, ResourceSymbolicOperator
 from .resource_container import CompressedResourceOp, Resources
 
 from .ops import (
+    ResourceAdjoint,
     ResourceCNOT,
+    ResourceControlled,
     ResourceControlledPhaseShift,
+    ResourcePow,
     ResourceHadamard,
     ResourceRZ,
     ResourceSWAP,

pennylane/labs/resource_estimation/ops/__init__.py

@@ -21,6 +21,9 @@
 )
 
 from .op_math import (
+    ResourceAdjoint,
     ResourceCNOT,
+    ResourceControlled,
     ResourceControlledPhaseShift,
+    ResourcePow,
 )

pennylane/labs/resource_estimation/ops/op_math/__init__.py

@@ -14,3 +14,4 @@
 r"""This module contains experimental resource estimation functionality. """
 
 from .controlled_ops import *
+from .symbolic import *

pennylane/labs/resource_estimation/ops/op_math/symbolic.py

@@ -0,0 +1,33 @@
+import pennylane as qml
+import pennylane.labs.resource_estimation as re
+from pennylane.ops.op_math.adjoint import AdjointOperation
+
+#pylint: disable=too-many-ancestors
+
+class ResourceAdjoint(AdjointOperation, re.ResourceSymbolicOperator):
+    """Resource class for Adjoint"""
+
+    @staticmethod
+    def _resource_decomp(*args, **kwargs, base_class, base_params):
+        try:
+            return base_class.adjoint_resource_rep()
+
+class ResourceControlled(qml.ops.Controlled, re.ResourceSymbolicOperator):
+    """Resource class for Controlled"""
+
+    @staticmethod
+    def _resource_decomp(*args, **kwargs):
+        pass
+
+    def resource_params(self):
+        pass
+
+class ResourcePow(qml.ops.Pow, re.ResourceSymbolicOperator):
+    """Resource class for Pow"""
+
+    @staticmethod
+    def _resource_decomp(*args, **kwargs):
+        pass
+
+    def resource_params(self):
+        pass

pennylane/labs/resource_estimation/resource_operator.py

@@ -20,6 +20,8 @@
 if TYPE_CHECKING:
     from pennylane.labs.resource_estimation import CompressedResourceOp
 
+import pennylane.labs.resource_estimation as re
+
 
 class ResourceOperator(ABC):
     r"""This is an abstract class that defines the methods a PennyLane Operator
@@ -95,6 +97,37 @@ def resource_rep_from_op(self) -> CompressedResourceOp:
         """Returns a compressed representation directly from the operator"""
         return self.__class__.resource_rep(**self.resource_params())
 
+    @classmethod
+    def adjoint_resource_rep(cls, *args, **kwargs) -> CompressedResourceOp:
+        """Returns a compressed representation of the adjoint of the operator"""
+        raise CompressedRepNotDefined
+
+    @classmethod
+    def controlled_resource_rep(cls, *args, **kwargs) -> CompressedResourceOp:
+        """Returns a compressed representation of the controlled version of the operator"""
+        raise CompressedRepNotDefined
+
+    @classmethod
+    def pow_resource_rep(cls, exponent, *args, **kwargs) -> CompressedResourceOp:
+        """Returns a compressed representation of the operator raised to a power"""
+        raise CompressedRepNotDefined
+
+class ResourceSymbolicOperator(ResourceOperator):
+    """Base class for resources of symbolic operators"""
+
+    #pylint: disable=no-member
+    def resource_params(self):
+        return {
+            "base_class": type(self.base),
+            "base_params": self.base.resource_params()
+        }
+
+    @classmethod
+    def resource_rep(cls, base_class, base_params, **kwargs):
+        return re.CompressedResourceOp(cls, {"base_class": base_class, "base_params": base_params})
 
 class ResourcesNotDefined(Exception):
     """Exception to be raised when a ``ResourceOperator`` does not implement _resource_decomp"""
+
+class CompressedRepNotDefined(Exception):
+    """Exception to be raised when a compressed representation is not defined"""