Port subroutine resource templates to estimator

doc/code/qml_estimator.rst

@@ -52,3 +52,12 @@ Resource Operators:
     :classes-only:
     :noindex:
 
+
+Resource Templates:
+-------------------
+
+.. automodsumm:: pennylane.estimator.templates
+    :toctree: api
+    :no-inherited-members:
+    :classes-only:
+    :noindex:

doc/conf.py

@@ -334,14 +334,16 @@
 # inheritance_diagram graphviz attributes
 inheritance_node_attrs = dict(color="lightskyblue1", style="filled")
 
+
 # pylint: disable=unused-argument
 def add_noindex_to_estimator_stubs(app, docname, source):
     """Dynamically add :noindex: to estimator stubs during the build process."""
     if not docname.startswith("code/api/"):
         return
 
     content = source[0]
-    if not re.search(r"\bpennylane\.estimator\.ops\b", content):
+    # Update the regex to match either ops or templates
+    if not re.search(r"\bpennylane\.estimator\.(ops|templates)\b", content):
         return
 
     def _add_noindex_func(match):
@@ -366,17 +368,21 @@ def _add_noindex_func(match):
 
 def add_links_to_estimator_table(app, doctree, fromdocname):
     """Replace literal names in automodsumm tables with links to stub HTML files."""
-    if "qml_estimator" in fromdocname: # Ensures no other tables are modified.
-        for table in doctree.traverse(nodes.table)[3:]:
-            for literal in table.traverse(nodes.literal):
-                name = literal.astext()
-                url = f"code/api/pennylane.estimator.ops.{name}"
-                refuri = app.builder.get_relative_uri(fromdocname, url)
-
-                refnode = nodes.reference('', refuri=refuri)
-                refnode += nodes.literal(text=name) # This helps preserve the code style.
-                literal.parent.replace(literal, refnode)
-                logger.info(f"[add_noindex_links] Linked pennylane.estimator.ops.{name} to {refuri}")
+    if "qml_estimator" not in fromdocname:
+        return
+    # Define the modules and their corresponding table indices
+    modules = {3: "ops", 4: "templates"}
+    for table_idx, module_name in modules.items():
+        table = doctree.traverse(nodes.table)[table_idx]
+        for literal in table.traverse(nodes.literal):
+            name = literal.astext()
+            url = f"code/api/pennylane.estimator.{module_name}.{name}"
+            refuri = app.builder.get_relative_uri(fromdocname, url)
+            refnode = nodes.reference('', refuri=refuri)
+            refnode += nodes.literal(text=name)
+            literal.parent.replace(literal, refnode)
+            logger.info(
+                f"[add_noindex_links] Linked pennylane.estimator.{module_name}.{name} to {refuri}")
 
 
 def setup(app):

doc/releases/changelog-dev.md

@@ -67,6 +67,10 @@
   * The resource operators for ``Pow``, ``Prod``, ``ChangeOpBasis``, and parametric multi-qubit operators have been added to
     `qml.estimator.ops`.
     [(#8255)](https://github.com/PennyLaneAI/pennylane/pull/8255)
+  * The resource templates ``SemiAdder``, ``QFT``, ``AQFT``, ``BasisRotation``, ``Select``,
+    ``QROM``, ``SelectPauliRot``, ``QubitUnitary``, ``ControlledSequence``, ``QPE`` and
+    ``IterativeQPE`` were added to `qml.estimator.ops`.
+    [(#8300)](https://github.com/PennyLaneAI/pennylane/pull/8300)
 
 * Wires can now be dynamically allocated and deallocated in quantum functions with
   :func:`~.allocate` and :func:`~.deallocate`. These features unlock many important applications

pennylane/estimator/__init__.py

@@ -45,6 +45,7 @@
     MultiRZ,
     PauliRot,
     SingleExcitation,
+    QubitUnitary,
 )
 
 from .ops.op_math import (
@@ -68,3 +69,18 @@
     Prod,
     ChangeOpBasis,
 )
+from .templates import (
+    OutOfPlaceSquare,
+    PhaseGradient,
+    OutMultiplier,
+    SemiAdder,
+    QFT,
+    AQFT,
+    BasisRotation,
+    Select,
+    QROM,
+    SelectPauliRot,
+    ControlledSequence,
+    QPE,
+    IterativeQPE,
+)

pennylane/estimator/ops/__init__.py

@@ -31,6 +31,7 @@
     PauliRot,
     MultiRZ,
     SingleExcitation,
+    QubitUnitary,
 )
 
 from .op_math import (

pennylane/estimator/ops/qubit/__init__.py

@@ -33,3 +33,5 @@
 from .parametric_ops_multi_qubit import MultiRZ, PauliRot
 
 from .qchem_ops import SingleExcitation
+
+from .matrix_ops import QubitUnitary

pennylane/estimator/ops/qubit/matrix_ops.py

@@ -0,0 +1,169 @@
+# Copyright 2025 Xanadu Quantum Technologies Inc.
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+r"""Resource operators for QubitUnitary operation."""
+import pennylane.estimator as qre
+from pennylane.estimator.resource_operator import (
+    CompressedResourceOp,
+    GateCount,
+    ResourceOperator,
+    resource_rep,
+)
+from pennylane.estimator.templates import SelectPauliRot
+from pennylane.wires import WiresLike
+
+# pylint: disable=arguments-differ
+
+
+class QubitUnitary(ResourceOperator):
+    r"""Resource class for the QubitUnitary template.
+
+    Args:
+        num_wires (int): the number of qubits the operation acts upon
+        precision (Union[float, None], optional): The precision used when preparing the single qubit
+            rotations used to synthesize the n-qubit unitary.
+        wires (Sequence[int], None): the wires the operation acts on
+
+    Resources:
+        The resources are defined by combining the two equalities in `Möttönen and Vartiainen
+        (2005), Fig 14 <https://arxiv.org/pdf/quant-ph/0504100>`_ , we can express an :math:`n`
+        qubit unitary as four :math:`n - 1` qubit unitaries and three multiplexed rotations
+        via (:class:`~.pennylane.estimator.templates.subroutines.SelectPauliRot`). Specifically, the cost
+        is given by:
+
+        * 1-qubit unitary, the cost is approximated as a single :code:`RZ` rotation.
+
+        * 2-qubit unitary, the cost is approximated as four single qubit rotations and three :code:`CNOT` gates.
+
+        * 3-qubit unitary or more, the cost is given according to the reference above, recursively.
+
+    .. seealso:: The associated PennyLane operation :class:`~.pennylane.QubitUnitary`.
+
+    **Example**
+
+    The resources for this operation are computed using:
+
+    >>> import pennylane.estimator as qre
+    >>> qu = qre.QubitUnitary(num_wires=3)
+    >>> print(qre.estimate(qu, gate_set))
+    --- Resources: ---
+     Total qubits: 3
+     Total gates : 52
+     Qubit breakdown:
+      zeroed qubits: 0, any_state qubits: 0, algorithmic qubits: 3
+     Gate breakdown:
+      {'RZ': 24, 'CNOT': 24, 'RY': 4}
+    """
+
+    resource_keys = {"num_wires", "precision"}
+
+    def __init__(self, num_wires: int, precision: float | None = None, wires: WiresLike = None):
+        self.num_wires = num_wires
+        self.precision = precision
+        super().__init__(wires=wires)
+
+    @property
+    def resource_params(self) -> dict:
+        r"""Returns a dictionary containing the minimal information needed to compute the resources.
+
+        Returns:
+            dict: A dictionary containing the resource parameters:
+                * num_wires (int): the number of qubits the operation acts upon
+                * precision (Union[float, None], optional): The precision used when preparing the
+                  single qubit rotations used to synthesize the n-qubit unitary.
+        """
+        return {"num_wires": self.num_wires, "precision": self.precision}
+
+    @classmethod
+    def resource_rep(cls, num_wires, precision=None) -> CompressedResourceOp:
+        r"""Returns a compressed representation containing only the parameters of
+        the Operator that are needed to compute the resources.
+
+        Args:
+            num_wires (int): the number of qubits the operation acts upon
+            precision (Union[float, None], optional): The precision used when preparing the single
+                qubit rotations used to synthesize the n-qubit unitary.
+
+        Returns:
+            :class:`~.pennylane.estimator.resource_operator.CompressedResourceOp`: the operator in a compressed representation
+        """
+        params = {"num_wires": num_wires, "precision": precision}
+        return CompressedResourceOp(cls, num_wires, params)
+
+    @classmethod
+    def resource_decomp(cls, num_wires, precision=None) -> list[GateCount]:
+        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.
+
+        Args:
+            num_wires (int): the number of qubits the operation acts upon
+            precision (Union[float, None], optional): The precision used when preparing the single
+                qubit rotations used to synthesize the n-qubit unitary.
+
+        Resources:
+            The resources are defined by combining the two equalities in `Möttönen and Vartiainen
+            (2005), Fig 14 <https://arxiv.org/pdf/quant-ph/0504100>`_, we can express an :math:`n`-
+            qubit unitary as four :math:`n - 1`-qubit unitaries and three multiplexed rotations
+            via (:class:`~.pennylane.estimator.templates.subroutines.SelectPauliRot`). Specifically, the cost
+            is given by:
+
+            * 1-qubit unitary, the cost is approximated as a single :code:`RZ` rotation.
+
+            * 2-qubit unitary, the cost is approximated as four single qubit rotations and three :code:`CNOT` gates.
+
+            * 3-qubit unitary or more, the cost is given according to the reference above, recursively.
+
+        Returns:
+            list[:class:`~.pennylane.estimator.resource_operator.GateCount`]: A list of GateCount objects, where each object
+            represents a specific quantum gate and the number of times it appears
+            in the decomposition.
+        """
+        gate_lst = []
+
+        one_qubit_decomp_cost = [GateCount(resource_rep(qre.RZ, {"precision": precision}))]
+        two_qubit_decomp_cost = [
+            GateCount(resource_rep(qre.RZ, {"precision": precision}), 4),
+            GateCount(resource_rep(qre.CNOT), 3),
+        ]
+
+        if num_wires == 1:
+            return one_qubit_decomp_cost
+
+        if num_wires == 2:
+            return two_qubit_decomp_cost
+
+        for gc in two_qubit_decomp_cost:
+            gate_lst.append(4 ** (num_wires - 2) * gc)
+
+        for index in range(2, num_wires):
+            multiplex_z = resource_rep(
+                SelectPauliRot,
+                {
+                    "num_ctrl_wires": index,
+                    "rot_axis": "Z",
+                    "precision": precision,
+                },
+            )
+            multiplex_y = resource_rep(
+                SelectPauliRot,
+                {
+                    "num_ctrl_wires": index,
+                    "rot_axis": "Y",
+                    "precision": precision,
+                },
+            )
+
+            gate_lst.append(GateCount(multiplex_z, 2 * 4 ** (num_wires - (1 + index))))
+            gate_lst.append(GateCount(multiplex_y, 4 ** (num_wires - (1 + index))))
+
+        return gate_lst

pennylane/estimator/resource_config.py

@@ -12,13 +12,15 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 r"""This module contains the ResourceConfig class, which tracks the configuration for resource estimation"""
-
 from __future__ import annotations
 
 from collections.abc import Callable
 from enum import StrEnum
 from typing import TYPE_CHECKING
 
+from pennylane.estimator.ops.qubit import QubitUnitary
+from pennylane.estimator.templates import SelectPauliRot
+
 if TYPE_CHECKING:
     from pennylane.estimator.resource_operator import ResourceOperator
 
@@ -40,7 +42,10 @@ class ResourceConfig:
     def __init__(self) -> None:
         _DEFAULT_PRECISION = 1e-9
         _DEFAULT_BIT_PRECISION = 15
-        self.resource_op_precisions = {}
+        self.resource_op_precisions = {
+            SelectPauliRot: {"precision": _DEFAULT_PRECISION},
+            QubitUnitary: {"precision": _DEFAULT_PRECISION},
+        }
         self._custom_decomps = {}
         self._adj_custom_decomps = {}
         self._ctrl_custom_decomps = {}

pennylane/estimator/templates/__init__.py

@@ -0,0 +1,30 @@
+# Copyright 2025 Xanadu Quantum Technologies Inc.
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+r"""This module contains resource templates."""
+
+from .subroutines import (
+    OutOfPlaceSquare,
+    PhaseGradient,
+    OutMultiplier,
+    SemiAdder,
+    QFT,
+    AQFT,
+    BasisRotation,
+    Select,
+    QROM,
+    SelectPauliRot,
+    ControlledSequence,
+    QPE,
+    IterativeQPE,
+)