IQP Circuit and Resource Operator

doc/introduction/templates.rst

@@ -260,6 +260,10 @@ Other subroutines
 
 Other useful templates which do not belong to the previous categories can be found here.
 
+.. gallery-item::
+    :description: :doc:`Instantaneous Quantum Polynomial Circuit <../code/api/pennylane.IQP>`
+    :figure: _static/templates/subroutines/iqp.png
+
 .. gallery-item::
     :description: :doc:`Grover Diffusion Operator <../code/api/pennylane.GroverOperator>`
     :figure: _static/templates/subroutines/grover.svg

doc/releases/changelog-dev.md

@@ -14,6 +14,15 @@
   Hadamard gradient differentiation methods per [the paper](https://arxiv.org/pdf/2408.05406).
   [(#8640)](https://github.com/PennyLaneAI/pennylane/pull/8640)
 
+<h4>Instantaneous Quantum Polynomial Circuits </h4>
+
+* A new template for building an Instantaneous Quantum Polynomial (`~.IQP`) circuit has been added along with a 
+  lightweight version (based on the :class:`~.estimator.resource_operator.ResourceOperator` class) to rapidly 
+  estimate its resources. This unlocks easily estimating the resources of the IQP circuit introduced in the 
+  `Train on classical, deploy on quantum <https://arxiv.org/abs/2503.02934>`_ work for generative quantum machine 
+  learning.
+  [(#8748)](https://github.com/PennyLaneAI/pennylane/pull/8748)
+
 <h4>Pauli-based computation </h4>
 
 * Users can now perform rapid Clifford+T decomposition with :func:`pennylane.qjit` using the new 

pennylane/labs/resource_estimation/__init__.py

@@ -121,6 +121,7 @@
     ~ResourceSemiAdder
     ~ResourceQPE
     ~ResourceIterativeQPE
+    ~ResourceIQP
     ~ResourceControlledSequence
     ~ResourceQFT
     ~ResourceAQFT
@@ -227,6 +228,7 @@
     ResourcePhaseGradient,
     ResourceOutMultiplier,
     ResourceSemiAdder,
+    ResourceIQP,
     ResourceQFT,
     ResourceAQFT,
     ResourceBasisRotation,

pennylane/labs/resource_estimation/templates/__init__.py

@@ -18,6 +18,7 @@
     ResourcePhaseGradient,
     ResourceOutMultiplier,
     ResourceSemiAdder,
+    ResourceIQP,
     ResourceQFT,
     ResourceAQFT,
     ResourceBasisRotation,

pennylane/labs/resource_estimation/templates/subroutines.py

@@ -917,6 +917,148 @@ def resource_decomp(cls, base_cmpr_op, num_iter, **kwargs):
         return gate_counts
 
 
+class ResourceIQP(ResourceOperator):
+    r"""Resource class for IQP.
+
+    Args:
+        num_wires (int): the number of qubits the operation acts upon
+        pattern (list[list[list[int]]]): Specification of the trainable gates. Each element of gates corresponds to a
+            unique trainable parameter. Each sublist specifies the generators to which that parameter applies.
+            Generators are specified by listing the qubits on which an X operator acts.
+        spin_sym (bool, optional): If True, the circuit is equivalent to one where the initial state
+            :math:`\frac{1}{\sqrt(2)}(|00\dots0> + |11\dots1>)` is used in place of :math:`|00\dots0>`.
+        wires (Sequence[int], optional): the wires the operation acts on
+
+    **Example:**
+
+    We can inspect the resources used by an IQP subroutine by using `qml.specs`.
+
+    .. code-block:: python
+
+        import pennylane as qml
+
+        @qml.qnode(qml.device('lightning.qubit'))
+        def circuit():
+            qml.IQP(
+                weights=math.random.uniform(0, 2 * np.pi, 4),
+                pattern=[[[0]], [[1]], [[2]], [[3]]],
+                spin_sym=True,
+                num_wires=4,
+            )
+            return qml.state()
+
+    >>> print(qml.specs(circuit, level="device")())
+    Device: lightning.qubit
+    Device wires: None
+    Shots: Shots(total=None)
+    Level: device
+    Resource specifications:
+      Total qubit allocations: 4
+      Total gates: 13
+      Circuit depth: 4
+      Gate types:
+        PauliRot: 1
+        Hadamard: 8
+        MultiRZ: 4
+      Measurements:
+        state(all wires): 1
+
+    .. seealso:: :class:`~.IQP`
+
+    """
+
+    resource_keys = {"spin_sym", "pattern", "num_wires"}
+
+    def __init__(self, num_wires, pattern, spin_sym, wires=None) -> None:
+        self.num_wires = num_wires
+        self.spin_sym = spin_sym
+        self.pattern = pattern
+        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
+        """
+        return {
+            "spin_sym": self.spin_sym,
+            "pattern": self.pattern,
+            "num_wires": self.num_wires,
+        }
+
+    @classmethod
+    def resource_rep(cls, num_wires, pattern, spin_sym) -> 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
+            pattern (list[list[list[int]]]): Specification of the trainable gates. Each element of gates corresponds to a
+                unique trainable parameter. Each sublist specifies the generators to which that parameter applies.
+                Generators are specified by listing the qubits on which an X operator acts.
+            spin_sym (bool, optional): If True, the circuit is equivalent to one where the initial state
+                :math:`\frac{1}{\sqrt(2)}(|00\dots0> + |11\dots1>)` is used in place of :math:`|00\dots0>`.
+
+        Returns:
+            CompressedResourceOp: the operator in a compressed representation
+        """
+        return CompressedResourceOp(
+            cls,
+            num_wires,
+            {
+                "spin_sym": spin_sym,
+                "pattern": pattern,
+                "num_wires": num_wires,
+            },
+        )
+
+    @classmethod
+    def resource_decomp(cls, num_wires, pattern, spin_sym) -> 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
+            pattern (list[list[list[int]]]): Specification of the trainable gates. Each element of gates corresponds to a
+                unique trainable parameter. Each sublist specifies the generators to which that parameter applies.
+                Generators are specified by listing the qubits on which an X operator acts.
+            spin_sym (bool, optional): If True, the circuit is equivalent to one where the initial state
+                :math:`\frac{1}{\sqrt(2)}(|00\dots0> + |11\dots1>)` is used in place of :math:`|00\dots0>`.
+
+        Returns:
+            list[~.pennylane.labs.resource_estimation.GateCount]: A list of GateCount objects, where each object
+            represents a specific quantum gate and the number of times it appears
+            in the decomposition.
+        """
+        hadamard = resource_rep(re.ResourceHadamard)
+        pauli_rot = resource_rep(re.ResourcePauliRot, {"pauli_string": "Y" + "X" * (num_wires - 1)})
+
+        hadamard_counts = 2 * num_wires
+        multi_rz_counts = defaultdict(int)
+
+        for gate in pattern:
+            for gen in gate:
+                multi_rz_counts[len(gen)] += 1
+
+        ret = [GateCount(hadamard, hadamard_counts)]
+
+        if spin_sym:
+            ret.append(GateCount(pauli_rot, 1))
+
+        return ret + [
+            GateCount(resource_rep(re.ResourceMultiRZ, {"num_wires": wires}), counts)
+            for (wires, counts) in multi_rz_counts.items()
+        ]
+
+    @staticmethod
+    def tracking_name(num_wires, pattern, spin_sym) -> str:
+        r"""Returns the tracking name built with the operator's parameters."""
+        return f"IQP({num_wires}, {pattern}, {spin_sym})"
+
+
 class ResourceQFT(ResourceOperator):
     r"""Resource class for QFT.
 

pennylane/labs/tests/resource_estimation/templates/test_subroutines.py

@@ -785,6 +785,85 @@ def test_resources(self, base_op, num_iter, expected_res):
         assert op.resource_decomp(**op.resource_params) == expected_res
 
 
+class TestResourceIQP:
+    """Test the ResourceIQP class."""
+
+    @pytest.mark.parametrize(
+        ("num_wires", "pattern", "spin_sym"),
+        [
+            (4, [[[0]], [[1]], [[2]], [[3]]], False),
+            (
+                6,
+                [[[0]], [[4]], [[3]], [[2]], [[1]], [[5]]],
+                True,
+            ),
+        ],
+    )
+    def test_resource_params(self, num_wires, pattern, spin_sym):
+        """Test that the resource params are correct."""
+        op = plre.ResourceIQP(num_wires, pattern, spin_sym)
+        assert op.resource_params == {
+            "spin_sym": spin_sym,
+            "pattern": pattern,
+            "num_wires": num_wires,
+        }
+
+    @pytest.mark.parametrize(
+        ("num_wires", "pattern", "spin_sym"),
+        [
+            (4, [[[0]], [[1]], [[2]], [[3]]], False),
+            (
+                6,
+                [[[0]], [[1]], [[2]], [[3]], [[4]], [[5]]],
+                True,
+            ),
+        ],
+    )
+    def test_resource_rep(self, num_wires, pattern, spin_sym):
+        """Test that the compressed representation is correct."""
+        expected = plre.CompressedResourceOp(
+            plre.ResourceIQP,
+            num_wires,
+            {
+                "num_wires": num_wires,
+                "pattern": pattern,
+                "spin_sym": spin_sym,
+            },
+        )
+        assert (
+            plre.ResourceIQP.resource_rep(num_wires=num_wires, pattern=pattern, spin_sym=spin_sym)
+            == expected
+        )
+
+    @pytest.mark.parametrize(
+        ("num_wires", "pattern", "spin_sym", "expected_res"),
+        [
+            (
+                4,
+                [[[0]], [[1]], [[2]], [[3]]],
+                False,
+                [
+                    GateCount(resource_rep(plre.ResourceHadamard), 8),
+                    GateCount(resource_rep(plre.ResourceMultiRZ, {"num_wires": 1}), 4),
+                ],
+            ),
+            (
+                6,
+                [[[0]], [[1]], [[2]], [[3]], [[4]], [[5]]],
+                True,
+                [
+                    GateCount(resource_rep(plre.ResourceHadamard), 12),
+                    GateCount(resource_rep(plre.ResourcePauliRot, {"pauli_string": "YXXXXX"}), 1),
+                    GateCount(resource_rep(plre.ResourceMultiRZ, {"num_wires": 1}), 6),
+                ],
+            ),
+        ],
+    )
+    def test_resources(self, num_wires, pattern, spin_sym, expected_res):
+        """Test that the resources are correct."""
+        assert plre.ResourceIQP.resource_decomp(num_wires, pattern, spin_sym) == expected_res
+
+
 class TestResourceQFT:
     """Test the ResourceQFT class."""
 

pennylane/templates/subroutines/__init__.py

@@ -42,6 +42,7 @@
 from .aqft import AQFT
 from .amplitude_amplification import AmplitudeAmplification
 from .qram import BBQRAM
+from .iqp import IQP
 from .qrom import QROM
 from .gqsp import GQSP
 from .select_pauli_rot import SelectPauliRot
@@ -78,6 +79,7 @@
     "TrotterProduct",
     "trotterize",
     "Interferometer",
+    "IQP",
     "Permute",
     "QFT",
     "QuantumPhaseEstimation",