[Decomposition] controlled decomposition with single work wire

doc/releases/changelog-dev.md

@@ -203,6 +203,9 @@
   0: ──RX(0.00)──RY(1.57)──RX(3.14)──GlobalPhase(-1.57)─┤  <Z>
   ```
 
+* A new decomposition rule that uses a single work wire for decomposing multi-controlled operators is added.
+  [(#7383)](https://github.com/PennyLaneAI/pennylane/pull/7383)
+
 * A :func:`~.decomposition.register_condition` decorator is added that allows users to bind a condition to a
   decomposition rule for when it is applicable. The condition should be a function that takes the
   resource parameters of an operator as arguments and returns `True` or `False` based on whether

pennylane/decomposition/decomposition_graph.py

@@ -38,6 +38,7 @@
 from .symbolic_decomposition import (
     adjoint_rotation,
     cancel_adjoint,
+    controlled_decomp_with_work_wire,
     decompose_to_base,
     flip_control_adjoint,
     flip_pow_adjoint,
@@ -306,6 +307,9 @@ def _get_controlled_decompositions(
         # qubit unitary if the base operator has a matrix form.
         rules.append(to_controlled_qubit_unitary)
 
+        # There's always Lemma 7.11 from https://arxiv.org/abs/quant-ph/9503016.
+        rules.append(controlled_decomp_with_work_wire)
+
         return rules
 
     def solve(self, lazy=True):

pennylane/decomposition/symbolic_decomposition.py

@@ -293,6 +293,45 @@ def flip_control_adjoint(*_, wires, control_wires, control_values, work_wires, b
     )
 
 
+def _controlled_decomp_with_work_wire_condition(num_control_wires, num_work_wires, **__):
+    return num_work_wires > 1 and num_control_wires > 1
+
+
+def _controlled_decomp_with_work_wire_resource(
+    base_class, base_params, num_control_wires, num_work_wires, **__
+):
+    return {
+        controlled_resource_rep(qml.X, {}, num_control_wires, num_work_wires=num_work_wires - 1): 2,
+        controlled_resource_rep(base_class, base_params, 1, 0): 1,
+    }
+
+
+# pylint: disable=protected-access,unused-argument
+@register_condition(_controlled_decomp_with_work_wire_condition)
+@register_resources(_controlled_decomp_with_work_wire_resource)
+def _controlled_decomp_with_work_wire(
+    *params, wires, control_wires, control_values, work_wires, base, **__
+):
+    """Implements Lemma 7.11 from https://arxiv.org/abs/quant-ph/9503016."""
+    base_op = base._unflatten(*base._flatten())
+    qml.ctrl(
+        qml.X(work_wires[0]),
+        control=wires[: len(control_wires)],
+        control_values=control_values,
+        work_wires=work_wires[1:],
+    )
+    qml.ctrl(base_op, control=work_wires[0])
+    qml.ctrl(
+        qml.X(work_wires[0]),
+        control=wires[: len(control_wires)],
+        control_values=control_values,
+        work_wires=work_wires[1:],
+    )
+
+
+controlled_decomp_with_work_wire = flip_zero_control(_controlled_decomp_with_work_wire)
+
+
 def _to_controlled_qu_condition(base_class, **__):
     return base_class.has_matrix and base_class.num_wires == 1
 

tests/decomposition/test_decomposition_graph.py

@@ -492,6 +492,35 @@ def test_flip_controlled_adjoint(self, _):
             graph.decomposition(op)(*op.parameters, wires=op.wires, **op.hyperparameters)
         assert q.queue == [qml.adjoint(qml.ops.Controlled(qml.U1(0.5, wires=0), control_wires=[1]))]
 
+    def test_decompose_with_single_work_wire(self, _):
+        """Tests that the Lemma 7.11 decomposition from https://arxiv.org/pdf/quant-ph/9503016 is applied correctly."""
+
+        op = qml.ctrl(qml.Rot(0.123, 0.234, 0.345, wires=0), control=[1, 2, 3], work_wires=[4, 5])
+
+        graph = DecompositionGraph(
+            operations=[op],
+            gate_set={"MultiControlledX", "CRot"},
+        )
+        graph.solve()
+        with qml.queuing.AnnotatedQueue() as q:
+            graph.decomposition(op)(*op.parameters, wires=op.wires, **op.hyperparameters)
+        assert q.queue == [
+            qml.MultiControlledX(wires=[1, 2, 3, 4], work_wires=[5]),
+            qml.CRot(0.123, 0.234, 0.345, wires=[4, 0]),
+            qml.MultiControlledX(wires=[1, 2, 3, 4], work_wires=[5]),
+        ]
+        assert graph.resource_estimate(op) == to_resources(
+            {
+                resource_rep(
+                    qml.MultiControlledX,
+                    num_control_wires=3,
+                    num_zero_control_values=0,
+                    num_work_wires=1,
+                ): 2,
+                qml.CRot: 1,
+            }
+        )
+
 
 @patch(
     "pennylane.decomposition.decomposition_graph.list_decomps",

tests/decomposition/test_symbolic_decomposition.py

@@ -27,6 +27,7 @@
 from pennylane.decomposition.symbolic_decomposition import (
     adjoint_rotation,
     cancel_adjoint,
+    controlled_decomp_with_work_wire,
     controlled_resource_rep,
     flip_control_adjoint,
     flip_pow_adjoint,
@@ -706,6 +707,31 @@ def test_flip_control_adjoint(self):
             }
         )
 
+    @pytest.mark.unit
+    def test_controlled_decomp_with_work_wire(self):
+        """Tests the controlled decomposition with a single work wire (Lemma 7.11 from https://arxiv.org/pdf/quant-ph/9503016)."""
+
+        U = qml.Rot.compute_matrix(0.123, 0.234, 0.345)
+        op = qml.ctrl(qml.QubitUnitary(U, wires=0), control=[1, 2], work_wires=[3])
+
+        with queuing.AnnotatedQueue() as q:
+            qml.Projector([0], wires=3)
+            controlled_decomp_with_work_wire(*op.parameters, wires=op.wires, **op.hyperparameters)
+
+        mat = qml.matrix(qml.tape.QuantumScript.from_queue(q), wire_order=[0, 1, 2, 3])
+        expected_mat = qml.matrix(op @ qml.Projector([0], wires=3), wire_order=[0, 1, 2, 3])
+        assert qml.math.allclose(mat, expected_mat)
+
+    @pytest.mark.unit
+    def test_controlled_decomp_with_work_wire_not_applicable(self):
+        """Tests that the controlled_decomp_with_work_wire is not applicable sometimes."""
+
+        op = qml.ctrl(qml.RX(0.5, wires=0), control=[1], control_values=[0], work_wires=[3])
+        assert not controlled_decomp_with_work_wire.is_applicable(**op.resource_params)
+
+        op = qml.ctrl(qml.RX(0.5, wires=0), control=[1, 2])
+        assert not controlled_decomp_with_work_wire.is_applicable(**op.resource_params)
+
     def test_decompose_to_controlled_unitary(self):
         """Tests the decomposition to controlled qubit unitary"""