Merge remote-tracking branch 'refs/remotes/origin/add-arithmetic-dunders-to-transforms' into add-arithmetic-dunders-to-transforms

Author: JerryChen97

doc/releases/changelog-dev.md

@@ -160,6 +160,9 @@
   work wire and :class:`pennylane.TemporaryAND` operators to reduce the resources needed.
   [(#8549)](https://github.com/PennyLaneAI/pennylane/pull/8549)
 
+* A decomposition has been added to the adjoint of :class:`pennylane.TemporaryAND`. This decomposition relies on mid-circuit measurments and does not require any T gates.
+  [(#8633)](https://github.com/PennyLaneAI/pennylane/pull/8633)
+
 * The graph-based decomposition system now supports decomposition rules that contains mid-circuit measurements.
   [(#8079)](https://github.com/PennyLaneAI/pennylane/pull/8079)
 

pennylane/_version.py

@@ -16,4 +16,4 @@
 Version number (major.minor.patch[-label])
 """
 
-__version__ = "0.44.0-dev37"
+__version__ = "0.44.0-dev38"

pennylane/ops/functions/assert_valid.py

@@ -157,6 +157,8 @@ def _test_decomposition_rule(op, rule: DecompositionRule, skip_decomp_matrix_che
 
     actual_gate_counts = defaultdict(int)
     for _op in tape.operations:
+        if isinstance(_op, qml.ops.Conditional):
+            _op = _op.base
         resource_rep = qml.resource_rep(type(_op), **_op.resource_params)
         actual_gate_counts[resource_rep] += 1
 

pennylane/templates/subroutines/arithmetic/temporary_and.py

@@ -262,7 +262,23 @@ def _temporary_and(wires: WiresLike, **kwargs):
 
 
 add_decomps(TemporaryAND, _temporary_and)
-# TODO: add add_decomps("Adjoint(TemporaryAND)", _adjoint_TemporaryAND) when MCMs supported by the pipeline
+
+
+def _adjoint_temporary_and_resources(
+    base_class=None, base_params=None
+):  # pylint: disable=unused-argument
+    return {ops.Hadamard: 1, ops.MidMeasure: 1, ops.CZ: 1}
+
+
+@register_resources(_adjoint_temporary_and_resources)
+def _adjoint_TemporaryAND(wires: WiresLike, **kwargs):  # pylint: disable=unused-argument
+    r"""The implementation of adjoint TemporaryAND by mid-circuit measurements as found in https://arxiv.org/abs/1805.03662."""
+    ops.Hadamard(wires=wires[2])
+    m_0 = ops.measure(wires[2], reset=True)
+    ops.cond(m_0, ops.CZ)(wires=[wires[0], wires[1]])
+
+
+add_decomps("Adjoint(TemporaryAND)", _adjoint_TemporaryAND)
 
 Elbow = TemporaryAND
 r"""Elbow(wire, control_values)

tests/templates/subroutines/arithmetic/test_temporary_and.py

@@ -15,10 +15,13 @@
 Tests for the TemporaryAND template.
 """
 
+from functools import partial
+
 import pytest
 
 import pennylane as qml
 from pennylane.ops.functions.assert_valid import _test_decomposition_rule
+from pennylane.templates.subroutines.arithmetic.temporary_and import _adjoint_TemporaryAND
 
 
 class TestTemporaryAND:
@@ -43,7 +46,7 @@ def test_standard_validity(self):
         """Check the operation using the assert_valid function."""
 
         op = qml.TemporaryAND(wires=[0, "a", 2], control_values=(0, 0))
-        qml.ops.functions.assert_valid(op)
+        qml.ops.functions.assert_valid(op, skip_decomp_matrix_check=True)
 
     def test_correctness(self):
         """Tests the correctness of the TemporaryAND operator.
@@ -110,6 +113,112 @@ def test_and_decompositions(self):
         for rule in qml.list_decomps(qml.TemporaryAND):
             _test_decomposition_rule(qml.TemporaryAND([0, 1, 2], control_values=(0, 0)), rule)
 
+    @pytest.mark.parametrize("control_values", [(0, 0), (0, 1), (1, 0), (1, 1)])
+    def test_adjoint_temporary_and_decomposition(self, control_values):
+        """
+        Validate the MCM-based decomposition of Adjoint(TemporaryAND).
+        """
+        sys_wires = [0, 1, 2]
+        work_wires = [3]  # auxiliary qubit for deferred measure
+        dev = qml.device("default.qubit", wires=sys_wires + work_wires)
+
+        @qml.qnode(dev)
+        def circuit(a, b):
+            qml.BasisState(qml.math.array([a, b, 0], dtype=int), wires=sys_wires)
+            qml.TemporaryAND(wires=sys_wires, control_values=control_values)
+            _adjoint_TemporaryAND(wires=sys_wires)
+            return qml.probs(wires=sys_wires)
+
+        for a in (0, 1):
+            for b in (0, 1):
+                probs = circuit(a, b)
+                idx = (a << 2) | (b << 1)
+                assert qml.math.allclose(
+                    probs[idx], 1.0
+                ), f"Failed for a={a}, b={b}, cv={control_values}"
+
+    @pytest.mark.usefixtures("enable_graph_decomposition")
+    def test_adjoint_temporary_and_integration(self):
+        wires = [0, 1, "aux0", 2]
+        gate_set = {"X", "T", "Adjoint(T)", "Hadamard", "CX", "CZ", "MidMeasureMP", "Adjoint(S)"}
+
+        @qml.set_shots(1)
+        @qml.qnode(qml.device("default.qubit", wires=wires), interface=None)
+        @partial(
+            qml.transforms.decompose,
+            gate_set=gate_set,
+            fixed_decomps={
+                qml.Select: qml.templates.subroutines.select._select_decomp_unary  # pylint: disable=protected-access
+            },
+        )
+        def circuit():
+            ops = [qml.Z(2) for _ in range(4)]
+            qml.Select(ops, control=[0, 1], work_wires=["aux0"], partial=True)
+            return qml.sample(wires=wires)
+
+        tape = qml.workflow.construct_tape(circuit)()
+        expected_operators = [
+            qml.X(0),
+            qml.X(1),
+            qml.H("aux0"),
+            qml.adjoint(qml.T("aux0")),
+            qml.H("aux0"),
+            qml.CZ(wires=[1, "aux0"]),
+            qml.H("aux0"),
+            qml.T("aux0"),
+            qml.H("aux0"),
+            qml.CZ(wires=[0, "aux0"]),
+            qml.H("aux0"),
+            qml.adjoint(qml.T("aux0")),
+            qml.H("aux0"),
+            qml.CZ(wires=[1, "aux0"]),
+            qml.H("aux0"),
+            qml.T("aux0"),
+            qml.H("aux0"),
+            qml.adjoint(qml.S("aux0")),
+            qml.X(0),
+            qml.X(1),
+            qml.CZ(wires=["aux0", 2]),
+            qml.H("aux0"),
+            qml.CZ(wires=[0, "aux0"]),
+            qml.H("aux0"),
+            qml.X("aux0"),
+            qml.CZ(wires=["aux0", 2]),
+            qml.H("aux0"),
+            qml.CZ(wires=[0, "aux0"]),
+            qml.H("aux0"),
+            qml.H("aux0"),
+            qml.CZ(wires=[1, "aux0"]),
+            qml.H("aux0"),
+            qml.CZ(wires=["aux0", 2]),
+            qml.H("aux0"),
+            qml.CZ(wires=[0, "aux0"]),
+            qml.H("aux0"),
+            qml.CZ(wires=["aux0", 2]),
+            qml.H("aux0"),
+            qml.measurements.MidMeasureMP(wires=["aux0"], postselect=None, reset=True),
+            "ConditionalCZ",
+        ]
+
+        for op, exp_op in zip(tape.operations, expected_operators):
+            # manual check: each MidMeasure has a unique ID, which prevents
+            # qml.equal from treating two MidMeasure as equal.
+            if isinstance(op, qml.measurements.MidMeasureMP):
+                assert op.wires == exp_op.wires
+                assert op.postselect == exp_op.postselect
+                assert op.reset == exp_op.reset
+
+            # manual check for the conditional operator
+            elif isinstance(op, qml.ops.op_math.condition.Conditional):
+                assert exp_op == "ConditionalCZ"
+                assert isinstance(op.base, qml.CZ)
+                assert list(op.base.wires) == [0, 1]
+                meas = op.meas_val  # same as the expr passed to qml.cond
+                assert list(meas.wires) == ["aux0"]
+
+            else:
+                qml.assert_equal(op, exp_op)
+
     @pytest.mark.parametrize("control_values", [(0, 0), (0, 1), (1, 0), (1, 1)])
     def test_compute_matrix_temporary_and(self, control_values):
         """Tests that the matrix of the TemporaryAND operator is correct."""