Repository: PennyLaneAI/pennylane
Pull request #6973 (2025-02-18 15:11:41)

[RE] make `resource_params` a property
**Context:**

There were some conflicts with the ongoing decomposition work.

**Description of the Change:**

- Make `resource_params` a `@property`

After this change, the following usages:
```python
op.resource_params()
```
will be replaced with
```python
op.resource_params
```

**Benefits:**

More intuitive usage

**Possible Drawbacks:**

Ongoing resource estimation work may be affected.

[sc-85218]



Patch:
diff --git a/doc/releases/changelog-dev.md b/doc/releases/changelog-dev.md
index 8f77c47f1..98e35f91f 100644
--- a/doc/releases/changelog-dev.md
+++ b/doc/releases/changelog-dev.md
@@ -307,6 +307,9 @@
 * ``pennylane.labs.dla.lie_closure_dense`` is removed and integrated into ``qml.lie_closure`` using the new ``dense`` keyword.
   [(#6811)](https://github.com/PennyLaneAI/pennylane/pull/6811)
 
+* ``ResourceOperator.resource_params`` is changed to a property.
+  [(#6973)](https://github.com/PennyLaneAI/pennylane/pull/6973)
+
 <h3>Breaking changes 💔</h3>
 
 * `qml.gradients.gradient_transform.choose_trainable_params` has been renamed to `choose_trainable_param_indices`
diff --git a/pennylane/labs/resource_estimation/ops/identity.py b/pennylane/labs/resource_estimation/ops/identity.py
index 9d612a75e..2494c2e81 100644
--- a/pennylane/labs/resource_estimation/ops/identity.py
+++ b/pennylane/labs/resource_estimation/ops/identity.py
@@ -27,6 +27,7 @@ class ResourceIdentity(qml.Identity, re.ResourceOperator):
     def _resource_decomp(*args, **kwargs) -> Dict[re.CompressedResourceOp, int]:
         return {}
 
+    @property
     def resource_params(self) -> dict:
         return {}
 
@@ -56,6 +57,7 @@ class ResourceGlobalPhase(qml.GlobalPhase, re.ResourceOperator):
     def _resource_decomp(*args, **kwargs) -> Dict[re.CompressedResourceOp, int]:
         return {}
 
+    @property
     def resource_params(self) -> dict:
         return {}
 
diff --git a/pennylane/labs/resource_estimation/ops/op_math/controlled_ops.py b/pennylane/labs/resource_estimation/ops/op_math/controlled_ops.py
index 164236c18..f68c67bbc 100644
--- a/pennylane/labs/resource_estimation/ops/op_math/controlled_ops.py
+++ b/pennylane/labs/resource_estimation/ops/op_math/controlled_ops.py
@@ -52,6 +52,7 @@ class ResourceCH(qml.CH, re.ResourceOperator):
 
         return gate_types
 
+    @property
     def resource_params(self) -> dict:
         return {}
 
@@ -104,6 +105,7 @@ class ResourceCY(qml.CY, re.ResourceOperator):
 
         return gate_types
 
+    @property
     def resource_params(self) -> dict:
         return {}
 
@@ -154,6 +156,7 @@ class ResourceCZ(qml.CZ, re.ResourceOperator):
 
         return gate_types
 
+    @property
     def resource_params(self) -> dict:
         return {}
 
@@ -214,6 +217,7 @@ class ResourceCSWAP(qml.CSWAP, re.ResourceOperator):
 
         return gate_types
 
+    @property
     def resource_params(self) -> dict:
         return {}
 
@@ -263,6 +267,7 @@ class ResourceCCZ(qml.CCZ, re.ResourceOperator):
 
         return gate_types
 
+    @property
     def resource_params(self) -> dict:
         return {}
 
@@ -301,6 +306,7 @@ class ResourceCNOT(qml.CNOT, re.ResourceOperator):
     def _resource_decomp(**kwargs) -> Dict[re.CompressedResourceOp, int]:
         raise re.ResourcesNotDefined
 
+    @property
     def resource_params(self) -> dict:
         return {}
 
@@ -402,6 +408,7 @@ class ResourceToffoli(qml.Toffoli, re.ResourceOperator):
 
         return gate_types
 
+    @property
     def resource_params(self) -> dict:
         return {}
 
@@ -481,6 +488,7 @@ class ResourceMultiControlledX(qml.MultiControlledX, re.ResourceOperator):
         gate_types[cnot] = 36 * num_ctrl_wires - 111
         return gate_types
 
+    @property
     def resource_params(self) -> dict:
         num_control = len(self.hyperparameters["control_wires"])
         num_work_wires = len(self.hyperparameters["work_wires"])
@@ -567,6 +575,7 @@ class ResourceCRX(qml.CRX, re.ResourceOperator):
 
         return gate_types
 
+    @property
     def resource_params(self) -> dict:
         return {}
 
@@ -620,6 +629,7 @@ class ResourceCRY(qml.CRY, re.ResourceOperator):
 
         return gate_types
 
+    @property
     def resource_params(self) -> dict:
         return {}
 
@@ -673,6 +683,7 @@ class ResourceCRZ(qml.CRZ, re.ResourceOperator):
 
         return gate_types
 
+    @property
     def resource_params(self) -> dict:
         return {}
 
@@ -737,6 +748,7 @@ class ResourceCRot(qml.CRot, re.ResourceOperator):
 
         return gate_types
 
+    @property
     def resource_params(self) -> dict:
         return {}
 
@@ -787,6 +799,7 @@ class ResourceControlledPhaseShift(qml.ControlledPhaseShift, re.ResourceOperator
 
         return gate_types
 
+    @property
     def resource_params(self):
         return {}
 
diff --git a/pennylane/labs/resource_estimation/ops/op_math/symbolic.py b/pennylane/labs/resource_estimation/ops/op_math/symbolic.py
index a3622572d..afc220be5 100644
--- a/pennylane/labs/resource_estimation/ops/op_math/symbolic.py
+++ b/pennylane/labs/resource_estimation/ops/op_math/symbolic.py
@@ -47,8 +47,9 @@ class ResourceAdjoint(AdjointOperation, re.ResourceOperator):
 
             return gate_types
 
+    @property
     def resource_params(self) -> dict:
-        return {"base_class": type(self.base), "base_params": self.base.resource_params()}
+        return {"base_class": type(self.base), "base_params": self.base.resource_params}
 
     @classmethod
     def resource_rep(cls, base_class, base_params) -> re.CompressedResourceOp:
@@ -95,10 +96,11 @@ class ResourceControlled(ControlledOp, re.ResourceOperator):
 
         return gate_types
 
+    @property
     def resource_params(self) -> dict:
         return {
             "base_class": type(self.base),
-            "base_params": self.base.resource_params(),
+            "base_params": self.base.resource_params,
             "num_ctrl_wires": len(self.control_wires),
             "num_ctrl_values": len([val for val in self.control_values if not val]),
             "num_work_wires": len(self.work_wires),
@@ -175,10 +177,11 @@ class ResourcePow(PowOperation, re.ResourceOperator):
 
         return {base_class.resource_rep(**base_params): z}
 
+    @property
     def resource_params(self) -> dict:
         return {
             "base_class": type(self.base),
-            "base_params": self.base.resource_params(),
+            "base_params": self.base.resource_params,
             "z": self.z,
         }
 
@@ -227,6 +230,7 @@ class ResourceExp(Exp, re.ResourceOperator):
 
         raise re.ResourcesNotDefined
 
+    @property
     def resource_params(self):
         return _extract_exp_params(self.base, self.scalar, self.num_steps)
 
@@ -278,6 +282,7 @@ class ResourceProd(Prod, re.ResourceOperator):
             res[factor] += 1
         return res
 
+    @property
     def resource_params(self) -> Dict:
         try:
             cmpr_factors = tuple(factor.resource_rep_from_op() for factor in self.operands)
@@ -303,7 +308,7 @@ def _extract_exp_params(base_op, scalar, num_steps):
         )
 
     base_class = type(base_op)
-    base_params = base_op.resource_params() if isinstance_resource_op else {}
+    base_params = base_op.resource_params if isinstance_resource_op else {}
 
     return {
         "base_class": base_class,
diff --git a/pennylane/labs/resource_estimation/ops/qubit/non_parametric_ops.py b/pennylane/labs/resource_estimation/ops/qubit/non_parametric_ops.py
index c48d611d8..e3c82ef0a 100644
--- a/pennylane/labs/resource_estimation/ops/qubit/non_parametric_ops.py
+++ b/pennylane/labs/resource_estimation/ops/qubit/non_parametric_ops.py
@@ -27,6 +27,7 @@ class ResourceHadamard(qml.Hadamard, re.ResourceOperator):
     def _resource_decomp(**kwargs) -> Dict[re.CompressedResourceOp, int]:
         raise re.ResourcesNotDefined
 
+    @property
     def resource_params(self) -> dict:
         return {}
 
@@ -76,6 +77,7 @@ class ResourceS(qml.S, re.ResourceOperator):
 
         return gate_types
 
+    @property
     def resource_params(self) -> dict:
         return {}
 
@@ -155,6 +157,7 @@ class ResourceSWAP(qml.SWAP, re.ResourceOperator):
 
         return gate_types
 
+    @property
     def resource_params(self) -> dict:
         return {}
 
@@ -200,6 +203,7 @@ class ResourceT(qml.T, re.ResourceOperator):
     def _resource_decomp(**kwargs) -> Dict[re.CompressedResourceOp, int]:
         raise re.ResourcesNotDefined
 
+    @property
     def resource_params(self) -> dict:
         return {}
 
@@ -252,6 +256,7 @@ class ResourceX(qml.X, re.ResourceOperator):
 
         return gate_types
 
+    @property
     def resource_params(self) -> dict:
         return {}
 
@@ -318,6 +323,7 @@ class ResourceY(qml.Y, re.ResourceOperator):
 
         return gate_types
 
+    @property
     def resource_params(self) -> dict:
         return {}
 
@@ -368,6 +374,7 @@ class ResourceZ(qml.Z, re.ResourceOperator):
 
         return gate_types
 
+    @property
     def resource_params(self) -> dict:
         return {}
 
diff --git a/pennylane/labs/resource_estimation/ops/qubit/parametric_ops_multi_qubit.py b/pennylane/labs/resource_estimation/ops/qubit/parametric_ops_multi_qubit.py
index aa72b7556..069abd761 100644
--- a/pennylane/labs/resource_estimation/ops/qubit/parametric_ops_multi_qubit.py
+++ b/pennylane/labs/resource_estimation/ops/qubit/parametric_ops_multi_qubit.py
@@ -42,6 +42,7 @@ class ResourceMultiRZ(qml.MultiRZ, re.ResourceOperator):
 
         return gate_types
 
+    @property
     def resource_params(self):
         return {"num_wires": len(self.wires)}
 
@@ -149,6 +150,7 @@ class ResourcePauliRot(qml.PauliRot, re.ResourceOperator):
 
         return gate_types
 
+    @property
     def resource_params(self):
         return {
             "pauli_string": self.hyperparameters["pauli_word"],
@@ -232,6 +234,7 @@ class ResourceIsingXX(qml.IsingXX, re.ResourceOperator):
 
         return gate_types
 
+    @property
     def resource_params(self):
         return {}
 
@@ -304,6 +307,7 @@ class ResourceIsingYY(qml.IsingYY, re.ResourceOperator):
 
         return gate_types
 
+    @property
     def resource_params(self):
         return {}
 
@@ -380,6 +384,7 @@ class ResourceIsingXY(qml.IsingXY, re.ResourceOperator):
 
         return gate_types
 
+    @property
     def resource_params(self):
         return {}
 
@@ -462,6 +467,7 @@ class ResourceIsingZZ(qml.IsingZZ, re.ResourceOperator):
 
         return gate_types
 
+    @property
     def resource_params(self):
         return {}
 
@@ -533,6 +539,7 @@ class ResourcePSWAP(qml.PSWAP, re.ResourceOperator):
 
         return gate_types
 
+    @property
     def resource_params(self):
         return {}
 
diff --git a/pennylane/labs/resource_estimation/ops/qubit/parametric_ops_single_qubit.py b/pennylane/labs/resource_estimation/ops/qubit/parametric_ops_single_qubit.py
index ced18ce87..dc5bb20b1 100644
--- a/pennylane/labs/resource_estimation/ops/qubit/parametric_ops_single_qubit.py
+++ b/pennylane/labs/resource_estimation/ops/qubit/parametric_ops_single_qubit.py
@@ -55,6 +55,7 @@ class ResourcePhaseShift(qml.PhaseShift, re.ResourceOperator):
 
         return gate_types
 
+    @property
     def resource_params(self) -> dict:
         return {}
 
@@ -109,6 +110,7 @@ class ResourceRX(qml.RX, re.ResourceOperator):
     def _resource_decomp(config, **kwargs) -> Dict[re.CompressedResourceOp, int]:
         return _rotation_resources(epsilon=config["error_rx"])
 
+    @property
     def resource_params(self) -> dict:
         return {}
 
@@ -179,6 +181,7 @@ class ResourceRY(qml.RY, re.ResourceOperator):
     def _resource_decomp(config, **kwargs) -> Dict[re.CompressedResourceOp, int]:
         return _rotation_resources(epsilon=config["error_ry"])
 
+    @property
     def resource_params(self) -> dict:
         return {}
 
@@ -241,6 +244,7 @@ class ResourceRZ(qml.RZ, re.ResourceOperator):
     def _resource_decomp(config, **kwargs) -> Dict[re.CompressedResourceOp, int]:
         return _rotation_resources(epsilon=config["error_rz"])
 
+    @property
     def resource_params(self) -> dict:
         return {}
 
@@ -301,6 +305,7 @@ class ResourceRot(qml.Rot, re.ResourceOperator):
         gate_types = {ry: 1, rz: 2}
         return gate_types
 
+    @property
     def resource_params(self):
         return {}
 
diff --git a/pennylane/labs/resource_estimation/ops/qubit/qchem_ops.py b/pennylane/labs/resource_estimation/ops/qubit/qchem_ops.py
index e832314d2..f2acdee25 100644
--- a/pennylane/labs/resource_estimation/ops/qubit/qchem_ops.py
+++ b/pennylane/labs/resource_estimation/ops/qubit/qchem_ops.py
@@ -54,6 +54,7 @@ class ResourceSingleExcitation(qml.SingleExcitation, re.ResourceOperator):
 
         return gate_types
 
+    @property
     def resource_params(self):
         return {}
 
@@ -98,6 +99,7 @@ class ResourceSingleExcitationMinus(qml.SingleExcitationMinus, re.ResourceOperat
 
         return gate_types
 
+    @property
     def resource_params(self):
         return {}
 
@@ -142,6 +144,7 @@ class ResourceSingleExcitationPlus(qml.SingleExcitationPlus, re.ResourceOperator
 
         return gate_types
 
+    @property
     def resource_params(self):
         return {}
 
@@ -187,6 +190,7 @@ class ResourceDoubleExcitation(qml.DoubleExcitation, re.ResourceOperator):
 
         return gate_types
 
+    @property
     def resource_params(self):
         return {}
 
@@ -224,6 +228,7 @@ class ResourceDoubleExcitationMinus(qml.DoubleExcitationMinus, re.ResourceOperat
 
         return gate_types
 
+    @property
     def resource_params(self):
         return {}
 
@@ -260,6 +265,7 @@ class ResourceDoubleExcitationPlus(qml.DoubleExcitationPlus, re.ResourceOperator
 
         return gate_types
 
+    @property
     def resource_params(self):
         return {}
 
@@ -290,6 +296,7 @@ class ResourceOrbitalRotation(qml.OrbitalRotation, re.ResourceOperator):
 
         return gate_types
 
+    @property
     def resource_params(self):
         return {}
 
@@ -336,6 +343,7 @@ class ResourceFermionicSWAP(qml.FermionicSWAP, re.ResourceOperator):
 
         return gate_types
 
+    @property
     def resource_params(self):
         return {}
 
diff --git a/pennylane/labs/resource_estimation/resource_operator.py b/pennylane/labs/resource_estimation/resource_operator.py
index 68744a487..43d03d59b 100644
--- a/pennylane/labs/resource_estimation/resource_operator.py
+++ b/pennylane/labs/resource_estimation/resource_operator.py
@@ -56,6 +56,7 @@ class ResourceOperator(ABC):
 
                     return gate_types
 
+                @property
                 def resource_params(self, num_wires) -> dict:
                     return {"num_wires": num_wires}
 
@@ -69,7 +70,7 @@ class ResourceOperator(ABC):
         .. code-block:: bash
 
             >>> op = ResourceQFT(range(3))
-            >>> op.resources(**op.resource_params())
+            >>> op.resources(**op.resource_params)
             {Hadamard(): 3, SWAP(): 1, ControlledPhaseShift(): 3}
 
     """
@@ -91,6 +92,7 @@ class ResourceOperator(ABC):
         """Set a custom resource method."""
         cls.resources = new_func
 
+    @property
     @abstractmethod
     def resource_params(self) -> dict:
         """Returns a dictionary containing the minimal information needed to
@@ -104,7 +106,7 @@ class ResourceOperator(ABC):
 
     def resource_rep_from_op(self) -> CompressedResourceOp:
         """Returns a compressed representation directly from the operator"""
-        return self.__class__.resource_rep(**self.resource_params())
+        return self.__class__.resource_rep(**self.resource_params)
 
     @classmethod
     def adjoint_resource_decomp(cls, *args, **kwargs) -> Dict[CompressedResourceOp, int]:
@@ -137,7 +139,7 @@ class ResourceOperator(ABC):
 
     def tracking_name_from_op(self) -> str:
         """Returns the tracking name built with the operator's parameters."""
-        return self.__class__.tracking_name(**self.resource_params())
+        return self.__class__.tracking_name(**self.resource_params)
 
 
 class ResourcesNotDefined(Exception):
diff --git a/pennylane/labs/resource_estimation/templates/subroutines.py b/pennylane/labs/resource_estimation/templates/subroutines.py
index 70a75cfa2..0b0bc73a8 100644
--- a/pennylane/labs/resource_estimation/templates/subroutines.py
+++ b/pennylane/labs/resource_estimation/templates/subroutines.py
@@ -46,6 +46,7 @@ class ResourceQFT(qml.QFT, ResourceOperator):
 
         return gate_types
 
+    @property
     def resource_params(self) -> dict:
         return {"num_wires": len(self.wires)}
 
@@ -78,6 +79,7 @@ class ResourceQuantumPhaseEstimation(qml.QuantumPhaseEstimation, ResourceOperato
 
         return gate_types
 
+    @property
     def resource_params(self) -> dict:
         op = self.hyperparameters["unitary"]
         num_estimation_wires = len(self.hyperparameters["estimation_wires"])
@@ -90,7 +92,7 @@ class ResourceQuantumPhaseEstimation(qml.QuantumPhaseEstimation, ResourceOperato
 
         return {
             "base_class": type(op),
-            "base_params": op.resource_params(),
+            "base_params": op.resource_params,
             "num_estimation_wires": num_estimation_wires,
         }
 
@@ -145,6 +147,7 @@ class ResourceStatePrep(qml.StatePrep, ResourceOperator):
             gate_types[cnot] = cnot_count
         return gate_types
 
+    @property
     def resource_params(self) -> dict:
         return {"num_wires": len(self.wires)}
 
@@ -174,6 +177,7 @@ class ResourceBasisRotation(qml.BasisRotation, ResourceOperator):
         gate_types[single_excitation] = se_count
         return gate_types
 
+    @property
     def resource_params(self) -> dict:
         unitary_matrix = self.parameters[0]
         return {"dim_N": qml.math.shape(unitary_matrix)[0]}
@@ -211,6 +215,7 @@ class ResourceSelect(qml.Select, ResourceOperator):
 
         return gate_types
 
+    @property
     def resource_params(self) -> dict:
         ops = self.hyperparameters["ops"]
         cmpr_ops = tuple(op.resource_rep_from_op() for op in ops)
@@ -241,6 +246,7 @@ class ResourcePrepSelPrep(qml.PrepSelPrep, ResourceOperator):
         gate_types[prep_dag] = 1
         return gate_types
 
+    @property
     def resource_params(self) -> dict:
         ops = self.hyperparameters["ops"]
         cmpr_ops = tuple(op.resource_rep_from_op() for op in ops)
@@ -297,6 +303,7 @@ class ResourceReflection(qml.Reflection, ResourceOperator):
 
         return gate_types
 
+    @property
     def resource_params(self) -> dict:
         base_cmpr_rep = self.hyperparameters["base"].resource_rep_from_op()
         num_ref_wires = len(self.hyperparameters["reflection_wires"])
@@ -330,6 +337,7 @@ class ResourceQubitization(qml.Qubitization, ResourceOperator):
         gate_types[psp] = 1
         return gate_types
 
+    @property
     def resource_params(self) -> dict:
         lcu = self.hyperparameters["hamiltonian"]
         _, ops = lcu.terms()
diff --git a/pennylane/labs/resource_estimation/templates/trotter.py b/pennylane/labs/resource_estimation/templates/trotter.py
index dbac6b68e..2d5d693b9 100644
--- a/pennylane/labs/resource_estimation/templates/trotter.py
+++ b/pennylane/labs/resource_estimation/templates/trotter.py
@@ -86,6 +86,7 @@ class ResourceTrotterProduct(
 
         return gate_types
 
+    @property
     def resource_params(self) -> dict:
         n = self.hyperparameters["n"]
         base = self.hyperparameters["base"]
@@ -141,6 +142,7 @@ class ResourceTrotterizedQfunc(TrotterizedQfunc, ResourceOperator):
             gate_types[cp_rep] += 2 * n * (5 ** (k - 1))
         return gate_types
 
+    @property
     def resource_params(self) -> dict:
         with qml.QueuingManager.stop_recording():
             with qml.queuing.AnnotatedQueue() as q:
@@ -179,7 +181,7 @@ class ResourceTrotterizedQfunc(TrotterizedQfunc, ResourceOperator):
 
     def resource_rep_from_op(self) -> CompressedResourceOp:
         """Returns a compressed representation directly from the operator"""
-        return self.__class__.resource_rep(**self.resource_params(), name=self._name)
+        return self.__class__.resource_rep(**self.resource_params, name=self._name)
 
 
 def resource_trotterize(qfunc, n=1, order=2, reverse=False):


Test patch:
diff --git a/pennylane/labs/tests/resource_estimation/ops/op_math/test_controlled_ops.py b/pennylane/labs/tests/resource_estimation/ops/op_math/test_controlled_ops.py
index 146d5cdff..aaf583ec2 100644
--- a/pennylane/labs/tests/resource_estimation/ops/op_math/test_controlled_ops.py
+++ b/pennylane/labs/tests/resource_estimation/ops/op_math/test_controlled_ops.py
@@ -34,17 +34,17 @@ class TestResourceCH:
             re.ResourceHadamard.resource_rep(): 2,
             re.ResourceCNOT.resource_rep(): 1,
         }
-        assert self.op.resources(**self.op.resource_params()) == expected_resources
+        assert self.op.resources(**self.op.resource_params) == expected_resources
 
     def test_resource_rep(self):
         """Test the resource_rep produces the correct compressed representation."""
         expected_rep = re.CompressedResourceOp(re.ResourceCH, {})
-        assert self.op.resource_rep(**self.op.resource_params()) == expected_rep
+        assert self.op.resource_rep(**self.op.resource_params) == expected_rep
 
     def test_resource_params(self):
         """Test that the resource_params are produced as expected."""
         expected_params = {}
-        assert self.op.resource_params() == expected_params
+        assert self.op.resource_params == expected_params
 
     def test_resource_adjoint(self):
         """Test that the adjoint resources are as expected"""
@@ -52,7 +52,7 @@ class TestResourceCH:
         op2 = re.ResourceAdjoint(self.op)
 
         assert self.op.adjoint_resource_decomp() == expected_res
-        assert op2.resources(**op2.resource_params()) == expected_res
+        assert op2.resources(**op2.resource_params) == expected_res
 
     ctrl_data = (
         (
@@ -93,7 +93,7 @@ class TestResourceCH:
             self.op.controlled_resource_decomp(num_ctrl_wires, num_ctrl_values, num_work_wires)
             == expected_res
         )
-        assert op2.resources(**op2.resource_params()) == expected_res
+        assert op2.resources(**op2.resource_params) == expected_res
 
     pow_data = (
         (1, {op.resource_rep(): 1}),
@@ -107,7 +107,7 @@ class TestResourceCH:
         op2 = re.ResourcePow(self.op, z)
 
         assert self.op.pow_resource_decomp(z) == expected_res
-        assert op2.resources(**op2.resource_params()) == expected_res
+        assert op2.resources(**op2.resource_params) == expected_res
 
 
 class TestResourceCY:
@@ -123,17 +123,17 @@ class TestResourceCY:
             re.ResourceCNOT.resource_rep(): 1,
             re.ResourceAdjoint.resource_rep(re.ResourceS, {}): 1,
         }
-        assert self.op.resources(**self.op.resource_params()) == expected_resources
+        assert self.op.resources(**self.op.resource_params) == expected_resources
 
     def test_resource_rep(self):
         """Test the resource_rep produces the correct compressed representation."""
         expected_rep = re.CompressedResourceOp(re.ResourceCY, {})
-        assert self.op.resource_rep(**self.op.resource_params()) == expected_rep
+        assert self.op.resource_rep(**self.op.resource_params) == expected_rep
 
     def test_resource_params(self):
         """Test that the resource_params are produced as expected."""
         expected_params = {}
-        assert self.op.resource_params() == expected_params
+        assert self.op.resource_params == expected_params
 
     def test_resource_adjoint(self):
         """Test that the adjoint resources are as expected"""
@@ -141,7 +141,7 @@ class TestResourceCY:
         op2 = re.ResourceAdjoint(self.op)
 
         assert self.op.adjoint_resource_decomp() == expected_res
-        assert op2.resources(**op2.resource_params()) == expected_res
+        assert op2.resources(**op2.resource_params) == expected_res
 
     ctrl_data = (
         (
@@ -182,7 +182,7 @@ class TestResourceCY:
             self.op.controlled_resource_decomp(num_ctrl_wires, num_ctrl_values, num_work_wires)
             == expected_res
         )
-        assert op2.resources(**op2.resource_params()) == expected_res
+        assert op2.resources(**op2.resource_params) == expected_res
 
     pow_data = (
         (1, {op.resource_rep(): 1}),
@@ -196,7 +196,7 @@ class TestResourceCY:
         op2 = re.ResourcePow(self.op, z)
 
         assert self.op.pow_resource_decomp(z) == expected_res
-        assert op2.resources(**op2.resource_params()) == expected_res
+        assert op2.resources(**op2.resource_params) == expected_res
 
 
 class TestResourceCZ:
@@ -211,7 +211,7 @@ class TestResourceCZ:
             re.ResourceHadamard.resource_rep(): 2,
             re.ResourceCNOT.resource_rep(): 1,
         }
-        assert self.op.resources(**self.op.resource_params()) == expected_resources
+        assert self.op.resources(**self.op.resource_params) == expected_resources
 
     def test_resource_rep(self):
         """Test the resource_rep produces the correct compressed representation."""
@@ -221,7 +221,7 @@ class TestResourceCZ:
     def test_resource_params(self):
         """Test that the resource_params are produced as expected."""
         expected_params = {}
-        assert self.op.resource_params() == expected_params
+        assert self.op.resource_params == expected_params
 
     def test_resource_adjoint(self):
         """Test that the adjoint resources are as expected"""
@@ -229,7 +229,7 @@ class TestResourceCZ:
         op2 = re.ResourceAdjoint(self.op)
 
         assert self.op.adjoint_resource_decomp() == expected_res
-        assert op2.resources(**op2.resource_params()) == expected_res
+        assert op2.resources(**op2.resource_params) == expected_res
 
     ctrl_data = (
         (
@@ -270,7 +270,7 @@ class TestResourceCZ:
             self.op.controlled_resource_decomp(num_ctrl_wires, num_ctrl_values, num_work_wires)
             == expected_res
         )
-        assert op2.resources(**op2.resource_params()) == expected_res
+        assert op2.resources(**op2.resource_params) == expected_res
 
     pow_data = (
         (1, {op.resource_rep(): 1}),
@@ -284,7 +284,7 @@ class TestResourceCZ:
         op2 = re.ResourcePow(self.op, z)
 
         assert self.op.pow_resource_decomp(z) == expected_res
-        assert op2.resources(**op2.resource_params()) == expected_res
+        assert op2.resources(**op2.resource_params) == expected_res
 
 
 class TestResourceCSWAP:
@@ -298,17 +298,17 @@ class TestResourceCSWAP:
             re.ResourceToffoli.resource_rep(): 1,
             re.ResourceCNOT.resource_rep(): 2,
         }
-        assert self.op.resources(**self.op.resource_params()) == expected_resources
+        assert self.op.resources(**self.op.resource_params) == expected_resources
 
     def test_resource_rep(self):
         """Test the resource_rep produces the correct compressed representation."""
         expected_rep = re.CompressedResourceOp(re.ResourceCSWAP, {})
-        assert self.op.resource_rep(**self.op.resource_params()) == expected_rep
+        assert self.op.resource_rep(**self.op.resource_params) == expected_rep
 
     def test_resource_params(self):
         """Test that the resource_params are produced as expected."""
         expected_params = {}
-        assert self.op.resource_params() == expected_params
+        assert self.op.resource_params == expected_params
 
     def test_resource_adjoint(self):
         """Test that the adjoint resources are as expected"""
@@ -316,7 +316,7 @@ class TestResourceCSWAP:
         op2 = re.ResourceAdjoint(self.op)
 
         assert self.op.adjoint_resource_decomp() == expected_res
-        assert op2.resources(**op2.resource_params()) == expected_res
+        assert op2.resources(**op2.resource_params) == expected_res
 
     ctrl_data = (
         (
@@ -357,7 +357,7 @@ class TestResourceCSWAP:
             self.op.controlled_resource_decomp(num_ctrl_wires, num_ctrl_values, num_work_wires)
             == expected_res
         )
-        assert op2.resources(**op2.resource_params()) == expected_res
+        assert op2.resources(**op2.resource_params) == expected_res
 
     pow_data = (
         (1, {op.resource_rep(): 1}),
@@ -371,7 +371,7 @@ class TestResourceCSWAP:
         op2 = re.ResourcePow(self.op, z)
 
         assert self.op.pow_resource_decomp(z) == expected_res
-        assert op2.resources(**op2.resource_params()) == expected_res
+        assert op2.resources(**op2.resource_params) == expected_res
 
 
 class TestResourceCCZ:
@@ -385,17 +385,17 @@ class TestResourceCCZ:
             re.ResourceHadamard.resource_rep(): 2,
             re.ResourceToffoli.resource_rep(): 1,
         }
-        assert self.op.resources(**self.op.resource_params()) == expected_resources
+        assert self.op.resources(**self.op.resource_params) == expected_resources
 
     def test_resource_rep(self):
         """Test the resource_rep produces the correct compressed representation."""
         expected_rep = re.CompressedResourceOp(re.ResourceCCZ, {})
-        assert self.op.resource_rep(**self.op.resource_params()) == expected_rep
+        assert self.op.resource_rep(**self.op.resource_params) == expected_rep
 
     def test_resource_params(self):
         """Test that the resource_params are produced as expected."""
         expected_params = {}
-        assert self.op.resource_params() == expected_params
+        assert self.op.resource_params == expected_params
 
     def test_resource_adjoint(self):
         """Test that the adjoint resources are as expected"""
@@ -403,7 +403,7 @@ class TestResourceCCZ:
         op2 = re.ResourceAdjoint(self.op)
 
         assert self.op.adjoint_resource_decomp() == expected_res
-        assert op2.resources(**op2.resource_params()) == expected_res
+        assert op2.resources(**op2.resource_params) == expected_res
 
     ctrl_data = (
         (
@@ -444,7 +444,7 @@ class TestResourceCCZ:
             self.op.controlled_resource_decomp(num_ctrl_wires, num_ctrl_values, num_work_wires)
             == expected_res
         )
-        assert op2.resources(**op2.resource_params()) == expected_res
+        assert op2.resources(**op2.resource_params) == expected_res
 
     pow_data = (
         (1, {op.resource_rep(): 1}),
@@ -458,7 +458,7 @@ class TestResourceCCZ:
         op2 = re.ResourcePow(self.op, z)
 
         assert self.op.pow_resource_decomp(z) == expected_res
-        assert op2.resources(**op2.resource_params()) == expected_res
+        assert op2.resources(**op2.resource_params) == expected_res
 
 
 class TestResourceCNOT:
@@ -479,7 +479,7 @@ class TestResourceCNOT:
     def test_resource_params(self):
         """Test that the resource_params are produced as expected."""
         expected_params = {}
-        assert self.op.resource_params() == expected_params
+        assert self.op.resource_params == expected_params
 
     def test_resource_adjoint(self):
         """Test that the adjoint resources are as expected"""
@@ -487,7 +487,7 @@ class TestResourceCNOT:
         op2 = re.ResourceAdjoint(self.op)
 
         assert self.op.adjoint_resource_decomp() == expected_res
-        assert op2.resources(**op2.resource_params()) == expected_res
+        assert op2.resources(**op2.resource_params) == expected_res
 
     ctrl_data = (
         (
@@ -528,7 +528,7 @@ class TestResourceCNOT:
             self.op.controlled_resource_decomp(num_ctrl_wires, num_ctrl_values, num_work_wires)
             == expected_res
         )
-        assert op2.resources(**op2.resource_params()) == expected_res
+        assert op2.resources(**op2.resource_params) == expected_res
 
     pow_data = (
         (1, {op.resource_rep(): 1}),
@@ -543,7 +543,7 @@ class TestResourceCNOT:
         op2 = re.ResourcePow(self.op, z)
 
         assert self.op.pow_resource_decomp(z) == expected_res
-        assert op2.resources(**op2.resource_params()) == expected_res
+        assert op2.resources(**op2.resource_params) == expected_res
 
 
 class TestResourceToffoli:
@@ -562,17 +562,17 @@ class TestResourceToffoli:
             re.ResourceCNOT.resource_rep(): 9,
             re.ResourceHadamard.resource_rep(): 3,
         }
-        assert self.op.resources(**self.op.resource_params()) == expected_resources
+        assert self.op.resources(**self.op.resource_params) == expected_resources
 
     def test_resource_rep(self):
         """Test the resource_rep produces the correct compressed representation."""
         expected_rep = re.CompressedResourceOp(re.ResourceToffoli, {})
-        assert self.op.resource_rep(**self.op.resource_params()) == expected_rep
+        assert self.op.resource_rep(**self.op.resource_params) == expected_rep
 
     def test_resource_params(self):
         """Test that the resource_params are produced as expected."""
         expected_params = {}
-        assert self.op.resource_params() == expected_params
+        assert self.op.resource_params == expected_params
 
     def test_resource_adjoint(self):
         """Test that the adjoint resources are as expected"""
@@ -580,7 +580,7 @@ class TestResourceToffoli:
         op2 = re.ResourceAdjoint(self.op)
 
         assert self.op.adjoint_resource_decomp() == expected_res
-        assert op2.resources(**op2.resource_params()) == expected_res
+        assert op2.resources(**op2.resource_params) == expected_res
 
     ctrl_data = (
         (
@@ -621,7 +621,7 @@ class TestResourceToffoli:
             self.op.controlled_resource_decomp(num_ctrl_wires, num_ctrl_values, num_work_wires)
             == expected_res
         )
-        assert op2.resources(**op2.resource_params()) == expected_res
+        assert op2.resources(**op2.resource_params) == expected_res
 
     pow_data = (
         (1, {op.resource_rep(): 1}),
@@ -636,7 +636,7 @@ class TestResourceToffoli:
         op2 = re.ResourcePow(self.op, z)
 
         assert self.op.pow_resource_decomp(z) == expected_res
-        assert op2.resources(**op2.resource_params()) == expected_res
+        assert op2.resources(**op2.resource_params) == expected_res
 
 
 class TestResourceMultiControlledX:
@@ -716,13 +716,13 @@ class TestResourceMultiControlledX:
         """Test the resource_rep produces the correct compressed representation."""
         op_resource_params = self._prep_params(*params)
         expected_rep = re.CompressedResourceOp(re.ResourceMultiControlledX, op_resource_params)
-        assert op.resource_rep(**op.resource_params()) == expected_rep
+        assert op.resource_rep(**op.resource_params) == expected_rep
 
     @pytest.mark.parametrize("op, params", zip(res_ops, res_params))
     def test_resource_params(self, op, params):
         """Test that the resource_params are produced as expected."""
         expected_params = self._prep_params(*params)
-        assert op.resource_params() == expected_params
+        assert op.resource_params == expected_params
 
     def test_resource_adjoint(self):
         """Test that the adjoint resources are as expected"""
@@ -732,11 +732,11 @@ class TestResourceMultiControlledX:
             work_wires=["w1"],
         )
 
-        expected_res = {op.resource_rep(**op.resource_params()): 1}
+        expected_res = {op.resource_rep(**op.resource_params): 1}
         op2 = re.ResourceAdjoint(op)
 
-        assert op.adjoint_resource_decomp(**op.resource_params()) == expected_res
-        assert op2.resources(**op2.resource_params()) == expected_res
+        assert op.adjoint_resource_decomp(**op.resource_params) == expected_res
+        assert op2.resources(**op2.resource_params) == expected_res
 
     ctrl_data = (
         (
@@ -783,11 +783,11 @@ class TestResourceMultiControlledX:
 
         assert (
             op.controlled_resource_decomp(
-                num_ctrl_wires, num_ctrl_values, num_work_wires, **op.resource_params()
+                num_ctrl_wires, num_ctrl_values, num_work_wires, **op.resource_params
             )
             == expected_res
         )
-        assert op2.resources(**op2.resource_params()) == expected_res
+        assert op2.resources(**op2.resource_params) == expected_res
 
     pow_data = (
         (1, {re.ResourceMultiControlledX.resource_rep(5, 3, 1): 1}),
@@ -807,8 +807,8 @@ class TestResourceMultiControlledX:
 
         op2 = re.ResourcePow(op, z)
 
-        assert op.pow_resource_decomp(z, **op.resource_params()) == expected_res
-        assert op2.resources(**op2.resource_params()) == expected_res
+        assert op.pow_resource_decomp(z, **op.resource_params) == expected_res
+        assert op2.resources(**op2.resource_params) == expected_res
 
 
 class TestResourceCRX:
@@ -824,17 +824,17 @@ class TestResourceCRX:
             re.ResourceHadamard.resource_rep(): 2,
             re.ResourceCNOT.resource_rep(): 2,
         }
-        assert self.op.resources(**self.op.resource_params()) == expected_resources
+        assert self.op.resources(**self.op.resource_params) == expected_resources
 
     def test_resource_rep(self):
         """Test the resource_rep produces the correct compressed representation."""
         expected_rep = re.CompressedResourceOp(re.ResourceCRX, {})
-        assert self.op.resource_rep(**self.op.resource_params()) == expected_rep
+        assert self.op.resource_rep(**self.op.resource_params) == expected_rep
 
     def test_resource_params(self):
         """Test that the resource_params are produced as expected."""
         expected_params = {}
-        assert self.op.resource_params() == expected_params
+        assert self.op.resource_params == expected_params
 
     def test_resource_adjoint(self):
         """Test that the adjoint resources are as expected"""
@@ -842,7 +842,7 @@ class TestResourceCRX:
         op2 = re.ResourceAdjoint(self.op)
 
         assert self.op.adjoint_resource_decomp() == expected_res
-        assert op2.resources(**op2.resource_params()) == expected_res
+        assert op2.resources(**op2.resource_params) == expected_res
 
     ctrl_data = (
         (
@@ -883,7 +883,7 @@ class TestResourceCRX:
             self.op.controlled_resource_decomp(num_ctrl_wires, num_ctrl_values, num_work_wires)
             == expected_res
         )
-        assert op2.resources(**op2.resource_params()) == expected_res
+        assert op2.resources(**op2.resource_params) == expected_res
 
     pow_data = (
         (1, {op.resource_rep(): 1}),
@@ -897,7 +897,7 @@ class TestResourceCRX:
         op2 = re.ResourcePow(self.op, z)
 
         assert self.op.pow_resource_decomp(z) == expected_res
-        assert op2.resources(**op2.resource_params()) == expected_res
+        assert op2.resources(**op2.resource_params) == expected_res
 
 
 class TestResourceCRY:
@@ -912,17 +912,17 @@ class TestResourceCRY:
             re.ResourceRY.resource_rep(): 2,
             re.ResourceCNOT.resource_rep(): 2,
         }
-        assert self.op.resources(**self.op.resource_params()) == expected_resources
+        assert self.op.resources(**self.op.resource_params) == expected_resources
 
     def test_resource_rep(self):
         """Test the resource_rep produces the correct compressed representation."""
         expected_rep = re.CompressedResourceOp(re.ResourceCRY, {})
-        assert self.op.resource_rep(**self.op.resource_params()) == expected_rep
+        assert self.op.resource_rep(**self.op.resource_params) == expected_rep
 
     def test_resource_params(self):
         """Test that the resource_params are produced as expected."""
         expected_params = {}
-        assert self.op.resource_params() == expected_params
+        assert self.op.resource_params == expected_params
 
     def test_resource_adjoint(self):
         """Test that the adjoint resources are as expected"""
@@ -930,7 +930,7 @@ class TestResourceCRY:
         op2 = re.ResourceAdjoint(self.op)
 
         assert self.op.adjoint_resource_decomp() == expected_res
-        assert op2.resources(**op2.resource_params()) == expected_res
+        assert op2.resources(**op2.resource_params) == expected_res
 
     ctrl_data = (
         (
@@ -971,7 +971,7 @@ class TestResourceCRY:
             self.op.controlled_resource_decomp(num_ctrl_wires, num_ctrl_values, num_work_wires)
             == expected_res
         )
-        assert op2.resources(**op2.resource_params()) == expected_res
+        assert op2.resources(**op2.resource_params) == expected_res
 
     pow_data = (
         (1, {op.resource_rep(): 1}),
@@ -985,7 +985,7 @@ class TestResourceCRY:
         op2 = re.ResourcePow(self.op, z)
 
         assert self.op.pow_resource_decomp(z) == expected_res
-        assert op2.resources(**op2.resource_params()) == expected_res
+        assert op2.resources(**op2.resource_params) == expected_res
 
 
 class TestResourceCRZ:
@@ -1000,17 +1000,17 @@ class TestResourceCRZ:
             re.ResourceRZ.resource_rep(): 2,
             re.ResourceCNOT.resource_rep(): 2,
         }
-        assert self.op.resources(**self.op.resource_params()) == expected_resources
+        assert self.op.resources(**self.op.resource_params) == expected_resources
 
     def test_resource_rep(self):
         """Test the resource_rep produces the correct compressed representation."""
         expected_rep = re.CompressedResourceOp(re.ResourceCRZ, {})
-        assert self.op.resource_rep(**self.op.resource_params()) == expected_rep
+        assert self.op.resource_rep(**self.op.resource_params) == expected_rep
 
     def test_resource_params(self):
         """Test that the resource_params are produced as expected."""
         expected_params = {}
-        assert self.op.resource_params() == expected_params
+        assert self.op.resource_params == expected_params
 
     def test_resource_adjoint(self):
         """Test that the adjoint resources are as expected"""
@@ -1018,7 +1018,7 @@ class TestResourceCRZ:
         op2 = re.ResourceAdjoint(self.op)
 
         assert self.op.adjoint_resource_decomp() == expected_res
-        assert op2.resources(**op2.resource_params()) == expected_res
+        assert op2.resources(**op2.resource_params) == expected_res
 
     ctrl_data = (
         (
@@ -1059,7 +1059,7 @@ class TestResourceCRZ:
             self.op.controlled_resource_decomp(num_ctrl_wires, num_ctrl_values, num_work_wires)
             == expected_res
         )
-        assert op2.resources(**op2.resource_params()) == expected_res
+        assert op2.resources(**op2.resource_params) == expected_res
 
     pow_data = (
         (1, {op.resource_rep(): 1}),
@@ -1073,7 +1073,7 @@ class TestResourceCRZ:
         op2 = re.ResourcePow(self.op, z)
 
         assert self.op.pow_resource_decomp(z) == expected_res
-        assert op2.resources(**op2.resource_params()) == expected_res
+        assert op2.resources(**op2.resource_params) == expected_res
 
 
 class TestResourceCRot:
@@ -1088,17 +1088,17 @@ class TestResourceCRot:
             re.ResourceRZ.resource_rep(): 3,
             re.ResourceCNOT.resource_rep(): 2,
         }
-        assert self.op.resources(**self.op.resource_params()) == expected_resources
+        assert self.op.resources(**self.op.resource_params) == expected_resources
 
     def test_resource_rep(self):
         """Test the resource_rep produces the correct compressed representation."""
         expected_rep = re.CompressedResourceOp(re.ResourceCRot, {})
-        assert self.op.resource_rep(**self.op.resource_params()) == expected_rep
+        assert self.op.resource_rep(**self.op.resource_params) == expected_rep
 
     def test_resource_params(self):
         """Test that the resource_params are produced as expected."""
         expected_params = {}
-        assert self.op.resource_params() == expected_params
+        assert self.op.resource_params == expected_params
 
     def test_resource_adjoint(self):
         """Test that the adjoint resources are as expected"""
@@ -1106,7 +1106,7 @@ class TestResourceCRot:
         op2 = re.ResourceAdjoint(self.op)
 
         assert self.op.adjoint_resource_decomp() == expected_res
-        assert op2.resources(**op2.resource_params()) == expected_res
+        assert op2.resources(**op2.resource_params) == expected_res
 
     ctrl_data = (
         (
@@ -1147,7 +1147,7 @@ class TestResourceCRot:
             self.op.controlled_resource_decomp(num_ctrl_wires, num_ctrl_values, num_work_wires)
             == expected_res
         )
-        assert op2.resources(**op2.resource_params()) == expected_res
+        assert op2.resources(**op2.resource_params) == expected_res
 
     pow_data = (
         (1, {op.resource_rep(): 1}),
@@ -1161,7 +1161,7 @@ class TestResourceCRot:
         op2 = re.ResourcePow(self.op, z)
 
         assert self.op.pow_resource_decomp(z) == expected_res
-        assert op2.resources(**op2.resource_params()) == expected_res
+        assert op2.resources(**op2.resource_params) == expected_res
 
 
 class TestResourceControlledPhaseShift:
@@ -1180,14 +1180,14 @@ class TestResourceControlledPhaseShift:
             re.CompressedResourceOp(re.ResourceRZ, {}): 3,
         }
 
-        assert op.resources(**op.resource_params()) == expected
+        assert op.resources(**op.resource_params) == expected
 
     @pytest.mark.parametrize("phi, wires", params)
     def test_resource_params(self, phi, wires):
         """Test the resource parameters"""
 
         op = re.ResourceControlledPhaseShift(phi, wires)
-        assert op.resource_params() == {}  # pylint: disable=use-implicit-booleaness-not-comparison
+        assert op.resource_params == {}  # pylint: disable=use-implicit-booleaness-not-comparison
 
     @pytest.mark.parametrize("phi, wires", params)
     def test_resource_rep(self, phi, wires):
@@ -1204,7 +1204,7 @@ class TestResourceControlledPhaseShift:
 
         op = re.ResourceControlledPhaseShift(phi, wires)
         assert op.resource_rep_from_op() == re.ResourceControlledPhaseShift.resource_rep(
-            **op.resource_params()
+            **op.resource_params
         )
 
     @pytest.mark.parametrize("phi, wires", params)
@@ -1285,4 +1285,4 @@ class TestResourceControlledPhaseShift:
             op.controlled_resource_decomp(num_ctrl_wires, num_ctrl_values, num_work_wires)
             == expected_res
         )
-        assert op2.resources(**op2.resource_params()) == expected_res
+        assert op2.resources(**op2.resource_params) == expected_res
diff --git a/pennylane/labs/tests/resource_estimation/ops/op_math/test_symbolic.py b/pennylane/labs/tests/resource_estimation/ops/op_math/test_symbolic.py
index 46cf54529..8877d5bda 100644
--- a/pennylane/labs/tests/resource_estimation/ops/op_math/test_symbolic.py
+++ b/pennylane/labs/tests/resource_estimation/ops/op_math/test_symbolic.py
@@ -49,6 +49,7 @@ class DummyOp(re.ResourceOperator, Operation):
     def exp_resource_decomp(cls, coeff, num_steps, a, b):  # pylint: disable=unused-argument
         return cls.resources(a + 1, b + 1)
 
+    @property
     def resource_params(self) -> dict:
         return {"a": self.a, "b": self.b}
 
@@ -109,7 +110,7 @@ class TestResourceAdjoint:
     @pytest.mark.parametrize("op, expected", zip(adjoint_ops, expected_params))
     def test_resource_params(self, op, expected):
         """Test that the resources are correct"""
-        assert op.resource_params() == expected
+        assert op.resource_params == expected
 
     expected_names = [
         "Adjoint(QFT(2))",
@@ -232,7 +233,7 @@ class TestResourceControlled:
     @pytest.mark.parametrize("op, expected", zip(controlled_ops, expected_params))
     def test_resource_params(self, op, expected):
         """Test that the resources are correct"""
-        assert op.resource_params() == expected
+        assert op.resource_params == expected
 
     expected_names = [
         "C(QFT(2),1,0,0)",
@@ -312,7 +313,7 @@ class TestResourcePow:
     @pytest.mark.parametrize("op, expected", zip(pow_ops, expected_params))
     def test_resource_params(self, op, expected):
         """Test that the resources are correct"""
-        assert op.resource_params() == expected
+        assert op.resource_params == expected
 
     expected_names = [
         "Pow(QFT(2), 2)",
@@ -435,7 +436,7 @@ class TestResourceProd:
     )
     def test_resources(self, op, params, expected_res):
         """Test the resources method returns the correct dictionary"""
-        res_from_op = op.resources(**op.resource_params())
+        res_from_op = op.resources(**op.resource_params)
         res_from_func = re.ResourceProd.resources(**params)
 
         assert res_from_op == expected_res
@@ -444,7 +445,7 @@ class TestResourceProd:
     @pytest.mark.parametrize("op, expected_params", zip(op_data, resource_params_data))
     def test_resource_params(self, op, expected_params):
         """Test that the resource params are correct"""
-        assert op.resource_params() == expected_params
+        assert op.resource_params == expected_params
 
     @pytest.mark.parametrize("expected_params", resource_params_data)
     def test_resource_rep(self, expected_params):
@@ -460,7 +461,7 @@ class TestResourceExp:
     def test_resource_params(self, op, expected):
         """Test that the resource_params method produces the expected parameters."""
         exp_op = re.ResourceExp(op, 1.2j, num_steps=3)
-        extracted_params = exp_op.resource_params()
+        extracted_params = exp_op.resource_params
         assert extracted_params == expected
 
     @pytest.mark.parametrize("op, expected_params", exp_params_data)
@@ -496,7 +497,7 @@ class TestResourceExp:
     @pytest.mark.parametrize("op, expected_resources", exp_res_data)
     def test_resources_decomp(self, op, expected_resources):
         """Test that the _resources_decomp method works as expected."""
-        computed_resources = op._resource_decomp(**op.resource_params())
+        computed_resources = op._resource_decomp(**op.resource_params)
         assert computed_resources == expected_resources
 
     @pytest.mark.parametrize(
@@ -536,7 +537,7 @@ class TestResourceExp:
     )
     def test_pow_resources(self, op, z, expected_resources):
         """Test that the pow resource decomp method works as expected."""
-        params = op.resource_params()
+        params = op.resource_params
         computed_resources = op.pow_resource_decomp(z, **params)
         assert computed_resources == expected_resources
 
diff --git a/pennylane/labs/tests/resource_estimation/ops/qubit/test_non_parametric_ops.py b/pennylane/labs/tests/resource_estimation/ops/qubit/test_non_parametric_ops.py
index 3d8da6411..306965fdd 100644
--- a/pennylane/labs/tests/resource_estimation/ops/qubit/test_non_parametric_ops.py
+++ b/pennylane/labs/tests/resource_estimation/ops/qubit/test_non_parametric_ops.py
@@ -33,7 +33,7 @@ class TestHadamard:
     def test_resource_params(self):
         """Test that the resource params are correct"""
         op = re.ResourceHadamard(0)
-        assert op.resource_params() == {}
+        assert op.resource_params == {}
 
     def test_resource_rep(self):
         """Test that the compact representation is correct"""
@@ -104,7 +104,7 @@ class TestHadamard:
             op.controlled_resource_decomp(num_ctrl_wires, num_ctrl_values, num_work_wires)
             == expected_res
         )
-        assert op2.resources(**op2.resource_params()) == expected_res
+        assert op2.resources(**op2.resource_params) == expected_res
 
     pow_data = (
         (1, {re.ResourceHadamard.resource_rep(): 1}),
@@ -120,7 +120,7 @@ class TestHadamard:
         assert op.pow_resource_decomp(z) == expected_res
 
         op2 = re.ResourcePow(op, z)
-        assert op2.resources(**op2.resource_params()) == expected_res
+        assert op2.resources(**op2.resource_params) == expected_res
 
 
 class TestSWAP:
@@ -137,7 +137,7 @@ class TestSWAP:
     def test_resource_params(self):
         """Test that the resource params are correct"""
         op = re.ResourceSWAP([0, 1])
-        assert op.resource_params() == {}
+        assert op.resource_params == {}
 
     def test_resource_rep(self):
         """Test the compact representation"""
@@ -219,7 +219,7 @@ class TestSWAP:
             op.controlled_resource_decomp(num_ctrl_wires, num_ctrl_values, num_work_wires)
             == expected_res
         )
-        assert op2.resources(**op2.resource_params()) == expected_res
+        assert op2.resources(**op2.resource_params) == expected_res
 
     pow_data = (
         (1, {re.ResourceSWAP.resource_rep(): 1}),
@@ -235,7 +235,7 @@ class TestSWAP:
         assert op.pow_resource_decomp(z) == expected_res
 
         op2 = re.ResourcePow(op, z)
-        assert op2.resources(**op2.resource_params()) == expected_res
+        assert op2.resources(**op2.resource_params) == expected_res
 
 
 class TestS:
@@ -250,7 +250,7 @@ class TestS:
     def test_resource_params(self):
         """Test that the resource params are correct"""
         op = re.ResourceS(0)
-        assert op.resource_params() == {}
+        assert op.resource_params == {}
 
     def test_resource_rep(self):
         """Test that the compressed representation is correct"""
@@ -298,7 +298,7 @@ class TestS:
         assert op.pow_resource_decomp(z) == expected_res
 
         op2 = re.ResourcePow(op, z)
-        assert op2.resources(**op2.resource_params()) == expected_res
+        assert op2.resources(**op2.resource_params) == expected_res
 
     ctrl_data = (
         (
@@ -357,7 +357,7 @@ class TestS:
             op.controlled_resource_decomp(num_ctrl_wires, num_ctrl_values, num_work_wires)
             == expected_res
         )
-        assert op2.resources(**op2.resource_params()) == expected_res
+        assert op2.resources(**op2.resource_params) == expected_res
 
 
 class TestT:
@@ -372,7 +372,7 @@ class TestT:
     def test_resource_params(self):
         """Test that the resource params are correct"""
         op = re.ResourceT(0)
-        assert op.resource_params() == {}
+        assert op.resource_params == {}
 
     def test_resource_rep(self):
         """Test that the compact representation is correct"""
@@ -448,7 +448,7 @@ class TestT:
             op.controlled_resource_decomp(num_ctrl_wires, num_ctrl_values, num_work_wires)
             == expected_res
         )
-        assert op2.resources(**op2.resource_params()) == expected_res
+        assert op2.resources(**op2.resource_params) == expected_res
 
     pow_data = (
         (1, {re.ResourceT.resource_rep(): 1}),
@@ -468,7 +468,7 @@ class TestT:
         assert op.pow_resource_decomp(z) == expected_res
 
         op2 = re.ResourcePow(op, z)
-        assert op2.resources(**op2.resource_params()) == expected_res
+        assert op2.resources(**op2.resource_params) == expected_res
 
 
 class TestX:
@@ -485,7 +485,7 @@ class TestX:
     def test_resource_params(self):
         """Test that the resource params are correct"""
         op = re.ResourceX(0)
-        assert op.resource_params() == {}
+        assert op.resource_params == {}
 
     def test_resource_rep(self):
         """Test that the compact representation is correct"""
@@ -564,7 +564,7 @@ class TestX:
             op.controlled_resource_decomp(num_ctrl_wires, num_ctrl_values, num_work_wires)
             == expected_res
         )
-        assert op2.resources(**op2.resource_params()) == expected_res
+        assert op2.resources(**op2.resource_params) == expected_res
 
     def test_adjoint_decomposition(self):
         """Test that the adjoint resources are correct."""
@@ -592,7 +592,7 @@ class TestX:
         assert op.pow_resource_decomp(z) == expected_res
 
         op2 = re.ResourcePow(op, z)
-        assert op2.resources(**op2.resource_params()) == expected_res
+        assert op2.resources(**op2.resource_params) == expected_res
 
 
 class TestY:
@@ -609,7 +609,7 @@ class TestY:
     def test_resource_params(self):
         """Test that the resource params are correct"""
         op = re.ResourceY(0)
-        assert op.resource_params() == {}
+        assert op.resource_params == {}
 
     def test_resource_rep(self):
         """Test that the compact representation is correct"""
@@ -682,7 +682,7 @@ class TestY:
             op.controlled_resource_decomp(num_ctrl_wires, num_ctrl_values, num_work_wires)
             == expected_res
         )
-        assert op2.resources(**op2.resource_params()) == expected_res
+        assert op2.resources(**op2.resource_params) == expected_res
 
     def test_adjoint_decomposition(self):
         """Test that the adjoint resources are correct."""
@@ -710,7 +710,7 @@ class TestY:
         assert op.pow_resource_decomp(z) == expected_res
 
         op2 = re.ResourcePow(op, z)
-        assert op2.resources(**op2.resource_params()) == expected_res
+        assert op2.resources(**op2.resource_params) == expected_res
 
 
 class TestZ:
@@ -726,7 +726,7 @@ class TestZ:
     def test_resource_params(self):
         """Test that the resource params are correct"""
         op = re.ResourceZ(0)
-        assert op.resource_params() == {}
+        assert op.resource_params == {}
 
     def test_resource_rep(self):
         """Test that the compact representation is correct"""
@@ -798,7 +798,7 @@ class TestZ:
             op.controlled_resource_decomp(num_ctrl_wires, num_ctrl_values, num_work_wires)
             == expected_res
         )
-        assert op2.resources(**op2.resource_params()) == expected_res
+        assert op2.resources(**op2.resource_params) == expected_res
 
     def test_adjoint_decomposition(self):
         """Test that the adjoint resources are correct."""
@@ -826,4 +826,4 @@ class TestZ:
         assert op.pow_resource_decomp(z) == expected_res
 
         op2 = re.ResourcePow(op, z)
-        assert op2.resources(**op2.resource_params()) == expected_res
+        assert op2.resources(**op2.resource_params) == expected_res
diff --git a/pennylane/labs/tests/resource_estimation/ops/qubit/test_parametric_ops_multi_qubit.py b/pennylane/labs/tests/resource_estimation/ops/qubit/test_parametric_ops_multi_qubit.py
index 54713fc12..24f37ec1e 100644
--- a/pennylane/labs/tests/resource_estimation/ops/qubit/test_parametric_ops_multi_qubit.py
+++ b/pennylane/labs/tests/resource_estimation/ops/qubit/test_parametric_ops_multi_qubit.py
@@ -27,7 +27,7 @@ class TestMultiRZ:
     def test_resource_params(self, num_wires):
         """Test that the resource params are correct."""
         op = re.ResourceMultiRZ(0.5, range(num_wires))
-        assert op.resource_params() == {"num_wires": num_wires}
+        assert op.resource_params == {"num_wires": num_wires}
 
     @pytest.mark.parametrize("num_wires", range(1, 10))
     def test_resource_rep(self, num_wires):
@@ -127,16 +127,16 @@ class TestMultiRZ:
         if num_ctrl_values != 0:
             with pytest.raises(re.ResourcesNotDefined):
                 op.controlled_resource_decomp(
-                    num_ctrl_wires, num_ctrl_values, num_work_wires, **op.resource_params()
+                    num_ctrl_wires, num_ctrl_values, num_work_wires, **op.resource_params
                 )
         else:
             assert (
                 op.controlled_resource_decomp(
-                    num_ctrl_wires, num_ctrl_values, num_work_wires, **op.resource_params()
+                    num_ctrl_wires, num_ctrl_values, num_work_wires, **op.resource_params
                 )
                 == expected_res
             )
-        assert op2.resources(**op2.resource_params()) == expected_res
+        assert op2.resources(**op2.resource_params) == expected_res
 
     pow_data = (
         (1, {re.ResourceMultiRZ.resource_rep(num_wires=4): 1}),
@@ -149,10 +149,10 @@ class TestMultiRZ:
     def test_pow_decomp(self, z, expected_res):
         """Test that the pow decomposition is correct."""
         op = re.ResourceMultiRZ(1.23, wires=range(4))
-        assert op.pow_resource_decomp(z, **op.resource_params()) == expected_res
+        assert op.pow_resource_decomp(z, **op.resource_params) == expected_res
 
         op2 = re.ResourcePow(op, z)
-        assert op2.resources(**op2.resource_params()) == expected_res
+        assert op2.resources(**op2.resource_params) == expected_res
 
 
 class TestPauliRot:
@@ -164,7 +164,7 @@ class TestPauliRot:
     def test_resource_params(self, pauli_string):
         """Test that the resource params are correct."""
         op = re.ResourcePauliRot(theta=0.5, pauli_word=pauli_string, wires=range(len(pauli_string)))
-        assert op.resource_params() == {"pauli_string": pauli_string}
+        assert op.resource_params == {"pauli_string": pauli_string}
 
     @pytest.mark.parametrize("pauli_string", pauli_words)
     def test_resource_rep(self, pauli_string):
@@ -357,11 +357,11 @@ class TestPauliRot:
 
         assert (
             op.controlled_resource_decomp(
-                num_ctrl_wires, num_ctrl_values, num_work_wires, **op.resource_params()
+                num_ctrl_wires, num_ctrl_values, num_work_wires, **op.resource_params
             )
             == expected_res
         )
-        assert op2.resources(**op2.resource_params()) == expected_res
+        assert op2.resources(**op2.resource_params) == expected_res
 
     @pytest.mark.parametrize("z", range(1, 5))
     @pytest.mark.parametrize("pauli_word", pauli_words)
@@ -369,10 +369,10 @@ class TestPauliRot:
         """Test that the pow decomposition is correct."""
         op = re.ResourcePauliRot(theta=0.5, pauli_word=pauli_word, wires=range(len(pauli_word)))
         expected_res = {re.ResourcePauliRot.resource_rep(pauli_string=pauli_word): 1}
-        assert op.pow_resource_decomp(z, **op.resource_params()) == expected_res
+        assert op.pow_resource_decomp(z, **op.resource_params) == expected_res
 
         op2 = re.ResourcePow(op, z)
-        assert op2.resources(**op2.resource_params()) == expected_res
+        assert op2.resources(**op2.resource_params) == expected_res
 
 
 class TestIsingXX:
@@ -381,7 +381,7 @@ class TestIsingXX:
     def test_resource_params(self):
         """Test that the resource params are correct."""
         op = re.ResourceIsingXX(0.5, wires=[0, 1])
-        assert op.resource_params() == {}
+        assert op.resource_params == {}
 
     def test_resource_rep(self):
         """Test that the compressed representation is correct."""
@@ -415,7 +415,7 @@ class TestIsingXY:
     def test_resource_params(self):
         """Test that the resource params are correct."""
         op = re.ResourceIsingXY(0.5, wires=[0, 1])
-        assert op.resource_params() == {}
+        assert op.resource_params == {}
 
     def test_resource_rep(self):
         """Test that the compressed representation is correct."""
@@ -453,7 +453,7 @@ class TestIsingYY:
     def test_resource_params(self):
         """Test that the resource params are correct."""
         op = re.ResourceIsingYY(0.5, wires=[0, 1])
-        assert op.resource_params() == {}
+        assert op.resource_params == {}
 
     def test_resource_rep(self):
         """Test that the compressed representation is correct."""
@@ -487,7 +487,7 @@ class TestIsingZZ:
     def test_resource_params(self):
         """Test that the resource params are correct."""
         op = re.ResourceIsingZZ(0.5, wires=[0, 1])
-        assert op.resource_params() == {}
+        assert op.resource_params == {}
 
     def test_resource_rep(self):
         """Test that the compressed representation is correct."""
@@ -521,7 +521,7 @@ class TestPSWAP:
     def test_resource_params(self):
         """Test that the resource params are correct."""
         op = re.ResourcePSWAP(0.5, wires=[0, 1])
-        assert op.resource_params() == {}
+        assert op.resource_params == {}
 
     def test_resource_rep(self):
         """Test that the compressed representation is correct."""
diff --git a/pennylane/labs/tests/resource_estimation/ops/qubit/test_parametric_ops_single_qubit.py b/pennylane/labs/tests/resource_estimation/ops/qubit/test_parametric_ops_single_qubit.py
index b39f54ec4..270bf4c1e 100644
--- a/pennylane/labs/tests/resource_estimation/ops/qubit/test_parametric_ops_single_qubit.py
+++ b/pennylane/labs/tests/resource_estimation/ops/qubit/test_parametric_ops_single_qubit.py
@@ -94,7 +94,7 @@ class TestPauliRotation:
     def test_resource_params(self, resource_class, epsilon):  # pylint: disable=unused-argument
         """Test that the resource params are correct"""
         op = resource_class(1.24, wires=0)
-        assert op.resource_params() == {}
+        assert op.resource_params == {}
 
     @pytest.mark.parametrize("resource_class", params_classes)
     @pytest.mark.parametrize("epsilon", params_errors)
@@ -209,7 +209,7 @@ class TestPauliRotation:
             op.controlled_resource_decomp(num_ctrl_wires, num_ctrl_values, num_work_wires)
             == expected_resources
         )
-        assert op2.resources(**op2.resource_params()) == expected_resources
+        assert op2.resources(**op2.resource_params) == expected_resources
 
 
 class TestRot:
@@ -245,7 +245,7 @@ class TestRot:
     def test_resource_params(self):
         """Test that the resource params are correct"""
         op = re.ResourceRot(0.1, 0.2, 0.3, wires=0)
-        assert op.resource_params() == {}
+        assert op.resource_params == {}
 
     def test_adjoint_decomp(self):
         """Test that the adjoint decomposition is correct"""
@@ -310,7 +310,7 @@ class TestRot:
             op.controlled_resource_decomp(num_ctrl_wires, num_ctrl_values, num_work_wires)
             == expected_res
         )
-        assert op2.resources(**op2.resource_params()) == expected_res
+        assert op2.resources(**op2.resource_params) == expected_res
 
     pow_data = (
         (0, {}),
@@ -326,7 +326,7 @@ class TestRot:
         assert op.pow_resource_decomp(z) == expected_res
 
         op2 = re.ResourcePow(op, z)
-        assert op2.resources(**op2.resource_params()) == expected_res
+        assert op2.resources(**op2.resource_params) == expected_res
 
 
 class TestPhaseShift:
@@ -363,7 +363,7 @@ class TestPhaseShift:
     def test_resource_params(self):
         """Test that the resource params are correct"""
         op = re.ResourcePhaseShift(0.1, wires=0)
-        assert op.resource_params() == {}
+        assert op.resource_params == {}
 
     def test_adjoint_decomp(self):
         """Test that the adjoint decomposition is correct"""
@@ -426,7 +426,7 @@ class TestPhaseShift:
             op.controlled_resource_decomp(num_ctrl_wires, num_ctrl_values, num_work_wires)
             == expected_res
         )
-        assert op2.resources(**op2.resource_params()) == expected_res
+        assert op2.resources(**op2.resource_params) == expected_res
 
     pow_data = (
         (0, {}),
@@ -442,4 +442,4 @@ class TestPhaseShift:
         assert op.pow_resource_decomp(z) == expected_res
 
         op2 = re.ResourcePow(op, z)
-        assert op2.resources(**op2.resource_params()) == expected_res
+        assert op2.resources(**op2.resource_params) == expected_res
diff --git a/pennylane/labs/tests/resource_estimation/ops/qubit/test_qchem_ops.py b/pennylane/labs/tests/resource_estimation/ops/qubit/test_qchem_ops.py
index 3a0690049..364502f20 100644
--- a/pennylane/labs/tests/resource_estimation/ops/qubit/test_qchem_ops.py
+++ b/pennylane/labs/tests/resource_estimation/ops/qubit/test_qchem_ops.py
@@ -38,7 +38,7 @@ class TestSingleExcitation:
     def test_resource_params(self):
         """Test that the resource params are correct."""
         op = re.ResourceSingleExcitation(0.5, wires=[0, 1])
-        assert op.resource_params() == {}
+        assert op.resource_params == {}
 
     def test_resource_rep(self):
         """Test that the compressed representation is correct."""
@@ -80,7 +80,7 @@ class TestSingleExcitationMinus:
     def test_resource_params(self):
         """Test that the resource params are correct."""
         op = re.ResourceSingleExcitationMinus(0.5, wires=[0, 1])
-        assert op.resource_params() == {}
+        assert op.resource_params == {}
 
     def test_resource_rep(self):
         """Test that the compressed representation is correct."""
@@ -118,7 +118,7 @@ class TestSingleExcitationPlus:
     def test_resource_params(self):
         """Test that the resource params are correct."""
         op = re.ResourceSingleExcitationPlus(0.5, wires=[0, 1])
-        assert op.resource_params() == {}
+        assert op.resource_params == {}
 
     def test_resource_rep(self):
         """Test that the compressed representation is correct."""
@@ -155,7 +155,7 @@ class TestDoubleExcitation:
     def test_resource_params(self):
         """Test that the resource params are correct."""
         op = re.ResourceDoubleExcitation(0.5, wires=[0, 1, 2, 3])
-        assert op.resource_params() == {}
+        assert op.resource_params == {}
 
     def test_resource_rep(self):
         """Test that the compressed representation is correct."""
@@ -192,7 +192,7 @@ class TestDoubleExcitationMinus:
     def test_resource_params(self):
         """Test that the resource params are correct."""
         op = re.ResourceDoubleExcitationMinus(0.5, wires=[0, 1, 2, 3])
-        assert op.resource_params() == {}
+        assert op.resource_params == {}
 
     def test_resource_rep(self):
         """Test that the compressed representation is correct."""
@@ -230,7 +230,7 @@ class TestDoubleExcitationPlus:
     def test_resource_params(self):
         """Test that the resource params are correct."""
         op = re.ResourceDoubleExcitationPlus(0.5, wires=[0, 1, 3, 4])
-        assert op.resource_params() == {}
+        assert op.resource_params == {}
 
     def test_resource_rep(self):
         """Test that the compressed representation is correct."""
@@ -266,7 +266,7 @@ class TestOrbitalRotation:
     def test_resource_params(self):
         """Test that the resource params are correct."""
         op = re.ResourceOrbitalRotation(0.5, wires=[0, 1, 3, 4])
-        assert op.resource_params() == {}
+        assert op.resource_params == {}
 
     def test_resource_rep(self):
         """Test that the compressed representation is correct."""
@@ -303,7 +303,7 @@ class TestFermionicSWAP:
     def test_resource_params(self):
         """Test that the resource params are correct."""
         op = re.ResourceFermionicSWAP(0.5, wires=[0, 1])
-        assert op.resource_params() == {}
+        assert op.resource_params == {}
 
     def test_resource_rep(self):
         """Test that the compressed representation is correct."""
diff --git a/pennylane/labs/tests/resource_estimation/ops/test_identity.py b/pennylane/labs/tests/resource_estimation/ops/test_identity.py
index f909d06bb..0cfb385c4 100644
--- a/pennylane/labs/tests/resource_estimation/ops/test_identity.py
+++ b/pennylane/labs/tests/resource_estimation/ops/test_identity.py
@@ -37,7 +37,7 @@ class TestIdentity:
     def test_resource_params(self):
         """Test the resource params are correct"""
         op = re.ResourceIdentity(0)
-        assert op.resource_params() == {}
+        assert op.resource_params == {}
 
     def test_resources_from_rep(self):
         """Test that the resources can be computed from the compressed representation"""
@@ -54,7 +54,7 @@ class TestIdentity:
         op = re.ResourceIdentity(0)
         op2 = re.ResourceAdjoint(op)
         assert op.adjoint_resource_decomp() == {re.ResourceIdentity.resource_rep(): 1}
-        assert op2.resources(**op2.resource_params()) == {re.ResourceIdentity.resource_rep(): 1}
+        assert op2.resources(**op2.resource_params) == {re.ResourceIdentity.resource_rep(): 1}
 
     identity_ctrl_data = (
         ([1], [1], [], {re.ResourceIdentity.resource_rep(): 1}),
@@ -80,7 +80,7 @@ class TestIdentity:
             op.controlled_resource_decomp(num_ctrl_wires, num_ctrl_values, num_work_wires)
             == expected_res
         )
-        assert op2.resources(**op2.resource_params()) == expected_res
+        assert op2.resources(**op2.resource_params) == expected_res
 
     identity_pow_data = (
         (1, {re.ResourceIdentity.resource_rep(): 1}),
@@ -95,7 +95,7 @@ class TestIdentity:
         assert op.pow_resource_decomp(z) == expected_res
 
         op2 = re.ResourcePow(op, z)
-        assert op2.resources(**op2.resource_params()) == expected_res
+        assert op2.resources(**op2.resource_params) == expected_res
 
 
 class TestGlobalPhase:
@@ -114,7 +114,7 @@ class TestGlobalPhase:
     def test_resource_params(self):
         """Test the resource params are correct"""
         op = re.ResourceGlobalPhase(0.1, wires=0)
-        assert op.resource_params() == {}
+        assert op.resource_params == {}
 
     def test_resources_from_rep(self):
         """Test that the resources can be computed from the compressed representation"""
@@ -131,7 +131,7 @@ class TestGlobalPhase:
         op = re.ResourceGlobalPhase(0.1, wires=0)
         op2 = re.ResourceAdjoint(op)
         assert op.adjoint_resource_decomp() == {re.ResourceGlobalPhase.resource_rep(): 1}
-        assert op2.resources(**op2.resource_params()) == {re.ResourceGlobalPhase.resource_rep(): 1}
+        assert op2.resources(**op2.resource_params) == {re.ResourceGlobalPhase.resource_rep(): 1}
 
     globalphase_ctrl_data = (
         ([1], [1], [], {re.ResourcePhaseShift.resource_rep(): 1}),
@@ -173,7 +173,7 @@ class TestGlobalPhase:
             op.controlled_resource_decomp(num_ctrl_wires, num_ctrl_values, num_work_wires)
             == expected_res
         )
-        assert op2.resources(**op2.resource_params()) == expected_res
+        assert op2.resources(**op2.resource_params) == expected_res
 
     globalphase_pow_data = (
         (1, {re.ResourceGlobalPhase.resource_rep(): 1}),
@@ -188,4 +188,4 @@ class TestGlobalPhase:
         assert op.pow_resource_decomp(z) == expected_res
 
         op2 = re.ResourcePow(op, z)
-        assert op2.resources(**op2.resource_params()) == expected_res
+        assert op2.resources(**op2.resource_params) == expected_res
diff --git a/pennylane/labs/tests/resource_estimation/templates/test_resource_basisrotation.py b/pennylane/labs/tests/resource_estimation/templates/test_resource_basisrotation.py
index 241c5fe01..54cb70f59 100644
--- a/pennylane/labs/tests/resource_estimation/templates/test_resource_basisrotation.py
+++ b/pennylane/labs/tests/resource_estimation/templates/test_resource_basisrotation.py
@@ -76,7 +76,7 @@ class TestBasisRotation:
     )
     def test_resources(self, op, params, expected_res):
         """Test the resources method returns the correct dictionary"""
-        res_from_op = op.resources(**op.resource_params())
+        res_from_op = op.resources(**op.resource_params)
         res_from_func = re.ResourceBasisRotation.resources(**params)
 
         assert res_from_op == expected_res
@@ -85,7 +85,7 @@ class TestBasisRotation:
     @pytest.mark.parametrize("op, expected_params", zip(op_data, resource_params_data))
     def test_resource_params(self, op, expected_params):
         """Test that the resource params are correct"""
-        assert op.resource_params() == expected_params
+        assert op.resource_params == expected_params
 
     @pytest.mark.parametrize("expected_params", resource_params_data)
     def test_resource_rep(self, expected_params):
diff --git a/pennylane/labs/tests/resource_estimation/templates/test_resource_prepselprep.py b/pennylane/labs/tests/resource_estimation/templates/test_resource_prepselprep.py
index eee99d047..ffd2cc7a9 100644
--- a/pennylane/labs/tests/resource_estimation/templates/test_resource_prepselprep.py
+++ b/pennylane/labs/tests/resource_estimation/templates/test_resource_prepselprep.py
@@ -160,7 +160,7 @@ class TestPrepSelPrep:
     )
     def test_resources(self, op, params, expected_res):
         """Test the resources method returns the correct dictionary"""
-        res_from_op = op.resources(**op.resource_params())
+        res_from_op = op.resources(**op.resource_params)
         res_from_func = re.ResourcePrepSelPrep.resources(**params)
 
         assert res_from_op == expected_res
@@ -169,7 +169,7 @@ class TestPrepSelPrep:
     @pytest.mark.parametrize("op, expected_params", zip(op_data, resource_params_data))
     def test_resource_params(self, op, expected_params):
         """Test that the resource params are correct"""
-        assert op.resource_params() == expected_params
+        assert op.resource_params == expected_params
 
     @pytest.mark.parametrize("expected_params", resource_params_data)
     def test_resource_rep(self, expected_params):
diff --git a/pennylane/labs/tests/resource_estimation/templates/test_resource_qft.py b/pennylane/labs/tests/resource_estimation/templates/test_resource_qft.py
index 8852965d7..52239c1fc 100644
--- a/pennylane/labs/tests/resource_estimation/templates/test_resource_qft.py
+++ b/pennylane/labs/tests/resource_estimation/templates/test_resource_qft.py
@@ -47,7 +47,7 @@ class TestQFT:
     def test_resource_params(self, wires):
         """Test that the resource params are correct"""
         op = re.ResourceQFT(wires)
-        assert op.resource_params() == {"num_wires": len(wires)}
+        assert op.resource_params == {"num_wires": len(wires)}
 
     @pytest.mark.parametrize("num_wires", [1, 2, 3, 4])
     def test_resource_rep(self, num_wires):
diff --git a/pennylane/labs/tests/resource_estimation/templates/test_resource_qpe.py b/pennylane/labs/tests/resource_estimation/templates/test_resource_qpe.py
index 21f518378..52653e12b 100644
--- a/pennylane/labs/tests/resource_estimation/templates/test_resource_qpe.py
+++ b/pennylane/labs/tests/resource_estimation/templates/test_resource_qpe.py
@@ -123,13 +123,13 @@ class TestQuantumPhaseEstimation:
         """Test that the resource params are correct"""
         unitary, estimation_wires = unitary_and_wires
         op = re.ResourceQuantumPhaseEstimation(unitary, estimation_wires=estimation_wires)
-        assert op.resource_params() == expected_params
+        assert op.resource_params == expected_params
 
     def test_resource_params_error(self):
         """Test that an error is raised if a resource operator is not provided."""
         with pytest.raises(TypeError, match="Can't obtain QPE resources when"):
             op = re.ResourceQuantumPhaseEstimation(qml.Hadamard(0), estimation_wires=[1, 2, 3])
-            op.resource_params()
+            op.resource_params  # pylint: disable=pointless-statement
 
     @pytest.mark.parametrize("expected_params", resource_params_data)
     def test_resource_rep(self, expected_params):
diff --git a/pennylane/labs/tests/resource_estimation/templates/test_resource_qubitization.py b/pennylane/labs/tests/resource_estimation/templates/test_resource_qubitization.py
index 9264a4109..2a9b6fc72 100644
--- a/pennylane/labs/tests/resource_estimation/templates/test_resource_qubitization.py
+++ b/pennylane/labs/tests/resource_estimation/templates/test_resource_qubitization.py
@@ -158,7 +158,7 @@ class TestQubitization:
     )
     def test_resources(self, op, params, expected_res):
         """Test the resources method returns the correct dictionary"""
-        res_from_op = op.resources(**op.resource_params())
+        res_from_op = op.resources(**op.resource_params)
         res_from_func = re.ResourceQubitization.resources(**params)
 
         assert res_from_op == expected_res
@@ -167,7 +167,7 @@ class TestQubitization:
     @pytest.mark.parametrize("op, expected_params", zip(op_data, resource_params_data))
     def test_resource_params(self, op, expected_params):
         """Test that the resource params are correct"""
-        assert op.resource_params() == expected_params
+        assert op.resource_params == expected_params
 
     @pytest.mark.parametrize("expected_params", resource_params_data)
     def test_resource_rep(self, expected_params):
diff --git a/pennylane/labs/tests/resource_estimation/templates/test_resource_reflection.py b/pennylane/labs/tests/resource_estimation/templates/test_resource_reflection.py
index 6a64fe15a..3b1cb708a 100644
--- a/pennylane/labs/tests/resource_estimation/templates/test_resource_reflection.py
+++ b/pennylane/labs/tests/resource_estimation/templates/test_resource_reflection.py
@@ -88,7 +88,7 @@ class TestReflection:
     )
     def test_resources(self, op, params, expected_res):
         """Test the resources method returns the correct dictionary"""
-        res_from_op = op.resources(**op.resource_params())
+        res_from_op = op.resources(**op.resource_params)
         res_from_func = re.ResourceReflection.resources(**params)
 
         assert res_from_op == expected_res
@@ -97,7 +97,7 @@ class TestReflection:
     @pytest.mark.parametrize("op, expected_params", zip(op_data, resource_params_data))
     def test_resource_params(self, op, expected_params):
         """Test that the resource params are correct"""
-        assert op.resource_params() == expected_params
+        assert op.resource_params == expected_params
 
     @pytest.mark.parametrize("expected_params", resource_params_data)
     def test_resource_rep(self, expected_params):
diff --git a/pennylane/labs/tests/resource_estimation/templates/test_resource_select.py b/pennylane/labs/tests/resource_estimation/templates/test_resource_select.py
index ea655e2fa..0d88801d7 100644
--- a/pennylane/labs/tests/resource_estimation/templates/test_resource_select.py
+++ b/pennylane/labs/tests/resource_estimation/templates/test_resource_select.py
@@ -172,7 +172,7 @@ class TestSelect:
     )
     def test_resources(self, op, params, expected_res):
         """Test the resources method returns the correct dictionary"""
-        res_from_op = op.resources(**op.resource_params())
+        res_from_op = op.resources(**op.resource_params)
         res_from_func = re.ResourceSelect.resources(**params)
 
         assert res_from_op == expected_res
@@ -181,7 +181,7 @@ class TestSelect:
     @pytest.mark.parametrize("op, expected_params", zip(op_data, resource_params_data))
     def test_resource_params(self, op, expected_params):
         """Test that the resource params are correct"""
-        assert op.resource_params() == expected_params
+        assert op.resource_params == expected_params
 
     @pytest.mark.parametrize("expected_params", resource_params_data)
     def test_resource_rep(self, expected_params):
diff --git a/pennylane/labs/tests/resource_estimation/templates/test_resource_stateprep.py b/pennylane/labs/tests/resource_estimation/templates/test_resource_stateprep.py
index 03c479422..3983bb236 100644
--- a/pennylane/labs/tests/resource_estimation/templates/test_resource_stateprep.py
+++ b/pennylane/labs/tests/resource_estimation/templates/test_resource_stateprep.py
@@ -77,7 +77,7 @@ class TestStatePrep:
     )
     def test_resources(self, op, params, expected_res):
         """Test the resources method returns the correct dictionary"""
-        res_from_op = op.resources(**op.resource_params())
+        res_from_op = op.resources(**op.resource_params)
         res_from_func = re.ResourceStatePrep.resources(**params)
 
         assert res_from_op == expected_res
@@ -86,7 +86,7 @@ class TestStatePrep:
     @pytest.mark.parametrize("op, expected_params", zip(op_data, resource_params_data))
     def test_resource_params(self, op, expected_params):
         """Test that the resource params are correct"""
-        assert op.resource_params() == expected_params
+        assert op.resource_params == expected_params
 
     @pytest.mark.parametrize("expected_params", resource_params_data)
     def test_resource_rep(self, expected_params):
diff --git a/pennylane/labs/tests/resource_estimation/templates/test_resource_trotter.py b/pennylane/labs/tests/resource_estimation/templates/test_resource_trotter.py
index 9bf72316f..f99dfd001 100644
--- a/pennylane/labs/tests/resource_estimation/templates/test_resource_trotter.py
+++ b/pennylane/labs/tests/resource_estimation/templates/test_resource_trotter.py
@@ -88,6 +88,7 @@ class DummyOp(re.ResourceOperator, Operation):
     def exp_resource_decomp(cls, coeff, num_steps, a, b):  # pylint: disable=unused-argument
         return cls.resources(a + 1, b + 1)
 
+    @property
     def resource_params(self) -> dict:
         return {"a": self.a, "b": self.b}
 
@@ -214,7 +215,7 @@ class TestResourceTrotterProduct:
     @pytest.mark.parametrize("op, expected_params", zip(op_data, resource_params_data))
     def test_resource_params(self, op, expected_params):
         """Test that the resource params are correct"""
-        assert op.resource_params() == expected_params
+        assert op.resource_params == expected_params
 
     @pytest.mark.parametrize("params", resource_params_data)
     def test_resource_rep(self, params):
@@ -285,7 +286,7 @@ class TestResourceTrotterizedQfunc:
     )
     def test_resource_params(self, op, expected_params):
         """Test that the resource params are correct"""
-        assert op.resource_params() == expected_params
+        assert op.resource_params == expected_params
 
     @pytest.mark.parametrize("params", resource_params_data)
     def test_resource_rep(self, params):
diff --git a/pennylane/labs/tests/resource_estimation/test_resource_operator.py b/pennylane/labs/tests/resource_estimation/test_resource_operator.py
index f88cb4f2c..68406d672 100644
--- a/pennylane/labs/tests/resource_estimation/test_resource_operator.py
+++ b/pennylane/labs/tests/resource_estimation/test_resource_operator.py
@@ -27,6 +27,7 @@ def test_abstract_resource_decomp():
     class DummyClass(re.ResourceOperator):
         """Dummy class for testing"""
 
+        @property
         def resource_params(self):
             return
 
@@ -71,6 +72,7 @@ def test_abstract_resource_rep():
         def _resource_decomp():
             return
 
+        @property
         def resource_params(self):
             return
 
@@ -87,6 +89,7 @@ def test_set_resources():
     class DummyClass(re.ResourceOperator):
         """Dummy class for testing"""
 
+        @property
         def resource_params(self):
             return
 
@@ -113,6 +116,7 @@ def test_resource_rep_from_op():
         def _resource_decomp():
             return
 
+        @property
         def resource_params(self):
             return {"foo": 1, "bar": 2}
 
@@ -125,4 +129,4 @@ def test_resource_rep_from_op():
             return f"DummyClass({foo}, {bar})"
 
     op = DummyClass(wires=[1, 2, 3])
-    assert op.resource_rep_from_op() == op.__class__.resource_rep(**op.resource_params())
+    assert op.resource_rep_from_op() == op.__class__.resource_rep(**op.resource_params)