Fix inversion of templates

.github/CHANGELOG.md

@@ -48,13 +48,17 @@
 
 <h3>Bug fixes</h3>
 
+* A bug which resulted in `qml.adjoint()` and `qml.inv()` failing to work with
+  templates has been fixed.
+  [(#1243)](https://github.com/PennyLaneAI/pennylane/pull/1243)
+
 <h3>Documentation</h3>
 
 <h3>Contributors</h3>
 
 This release contains contributions from:
 
-Thomas Bromley, Diego Guala, Anthony Hayes, Antal Száva
+Thomas Bromley, Diego Guala, Anthony Hayes, Josh Izaac, Antal Száva
 
 # Release 0.15.0 (current release)
 

pennylane/operation.py

@@ -589,16 +589,13 @@ def inverse(self):
         """Boolean determining if the inverse of the operation was requested."""
         return self._inverse
 
-    def adjoint(self, do_queue=False):
+    def adjoint(self):
         """Create an operation that is the adjoint of this one.
 
         Adjointed operations are the conjugated and transposed version of the
         original operation. Adjointed ops are equivalent to the inverted operation for unitary
         gates.
 
-        Args:
-            do_queue: Whether to add the adjointed gate to the context queue.
-
         Returns:
             The adjointed operation.
         """

pennylane/ops/qubit.py

@@ -2465,7 +2465,7 @@ def decomposition(state, wires):
         return MottonenStatePreparation(state, wires)
 
     def adjoint(self):
-        raise AdjointError("No adjoint exists for QubitStateVector operations.")
+        return qml.adjoint(MottonenStatePreparation)(self.parameters[0], wires=self.wires)
 
 
 # =============================================================================

pennylane/tape/tape.py

@@ -648,11 +648,40 @@ def inv(self):
         self.trainable_params = {parameter_mapping[i] for i in self.trainable_params}
         self._par_info = {parameter_mapping[k]: v for k, v in self._par_info.items()}
 
-        for op in self._ops:
-            op.inverse = not op.inverse
+        for idx, op in enumerate(self._ops):
+            try:
+                self._ops[idx] = op.adjoint()
+            except NotImplementedError:
+                op.inverse = not op.inverse
 
         self._ops = list(reversed(self._ops))
 
+    def adjoint(self):
+        """Create a tape that is the adjoint of this one.
+
+        Adjointed tapes are the conjugated and transposed version of the
+        original tapes. Adjointed ops are equivalent to the inverted operation for unitary
+        gates.
+
+        Returns:
+            ~.QuantumTape: the adjointed tape
+        """
+        new_tape = self.copy(copy_operations=True)
+        qml.transforms.invisible(new_tape.inv)()
+
+        # the current implementation of the adjoint
+        # transform requires that the returned inverted object
+        # is automatically queued.
+        QuantumTape._lock.acquire()
+        try:
+            QueuingContext.append(new_tape)
+        except Exception as _:
+            QuantumTape._lock.release()
+            raise
+        QuantumTape._lock.release()
+
+        return new_tape
+
     # ========================================================
     # Parameter handling
     # ========================================================

pennylane/templates/embeddings/amplitude.py

@@ -143,6 +143,11 @@ def __init__(self, features, wires, pad_with=None, normalize=False, pad=None, do
         features = self._preprocess(features, wires, pad_with, normalize)
         super().__init__(features, wires=wires, do_queue=do_queue)
 
+    def adjoint(self):
+        return qml.adjoint(qml.templates.MottonenStatePreparation)(
+            self.parameters[0], wires=self.wires
+        )
+
     def expand(self):
 
         with qml.tape.QuantumTape() as tape:

pennylane/templates/layers/particle_conserving_u1.py

@@ -266,13 +266,14 @@ def expand(self):
 
         with qml.tape.QuantumTape() as tape:
 
-            qml.BasisState(self.init_state, wires=self.wires)
+            qml.templates.BasisEmbedding(self.init_state, wires=self.wires)
 
             for l in range(self.n_layers):
                 for i, wires_ in enumerate(nm_wires):
                     u1_ex_gate(
                         self.parameters[0][l, i, 0], self.parameters[0][l, i, 1], wires=wires_
                     )
+
         return tape
 
     @staticmethod

pennylane/templates/layers/particle_conserving_u2.py

@@ -183,7 +183,7 @@ def expand(self):
 
         with qml.tape.QuantumTape() as tape:
 
-            qml.BasisState(self.init_state, wires=self.wires)
+            qml.templates.BasisEmbedding(self.init_state, wires=self.wires)
 
             for l in range(self.n_layers):
 

pennylane/transforms/adjoint.py

@@ -18,34 +18,51 @@
 
 
 def adjoint(fn):
-    """Create a function that applies the adjoint of the provided operation or template.
+    """Create a function that applies the adjoint (inverse) of the provided operation or template.
 
     This transform can be used to apply the adjoint of an arbitrary sequence of operations.
 
     Args:
-        fn (function): Any python function that applies pennylane operations.
+        fn (function): A quantum function that applies quantum operations.
 
     Returns:
         function: A new function that will apply the same operations but adjointed and in reverse order.
 
     **Example**
 
+    The adjoint transforms can be used within a QNode to apply the adjoint of
+    any quantum function. Consider the following quantum function, that applies two
+    operations:
+
     .. code-block:: python3
 
-        def my_ops():
-            qml.RX(0.123, wires=0)
-            qml.RY(0.456, wires=0)
+        def my_ops(a, b, wire):
+            qml.RX(a, wires=wire)
+            qml.RY(b, wires=wire)
+
+    We can create a QNode that applies this quantum function,
+    followed by the adjoint of this function:
+
+    .. code-block:: python3
+
+        dev = qml.device('default.qubit', wires=1)
+
+        @qml.qnode(dev)
+        def circuit(a, b):
+            my_ops(a, b, wire=0)
+            qml.adjoint(my_ops)(a, b, wire=0)
+            return qml.expval(qml.PauliZ(0))
+
+    Printing this out, we can see that the inverse quantum
+    function has indeed been applied:
 
-        with qml.tape.QuantumTape() as tape:
-            my_ops()
+    >>> print(qml.draw(circuit)(0.2, 0.5))
+     0: ──RX(0.2)──RY(0.5)──RY(-0.5)──RX(-0.2)──┤ ⟨Z⟩
 
-        with qml.tape.QuantumTape() as tape_adj:
-            qml.adjoint(my_ops)()
+    The adjoint function can also be applied directly to templates and operations:
 
-    >>> print(tape.operations)
-    [RX(0.123, wires=[0]), RY(0.456, wires=[0])]
-    >>> print(tape_adj.operatioins)
-    [RY(-0.456, wires=[0]), RX(-0.123, wires=[0])]
+    >>> qml.adjoint(qml.RX)(0.123, wires=0)
+    >>> qml.adjoint(qml.templates.StronglyEntanglingLayers)(weights, wires=[0, 1])
 
     .. UsageDetails::
 
@@ -102,9 +119,10 @@ def wrapper(*args, **kwargs):
             try:
                 op.adjoint()
             except NotImplementedError:
-                # Decompose the operation and adjoint the result.
+                # Expand the operation and adjoint the result.
                 # We do not do anything with the output since
-                # decomposition will automatically queue the new operations.
-                adjoint(op.decomposition)(wires=op.wires)
+                # calling adjoint on the expansion will automatically
+                # queue the new operations.
+                adjoint(op.expand)()
 
     return wrapper

pennylane/utils.py

@@ -305,8 +305,9 @@ def circuit2():
             "Please use inv on the function including its arguments, as in inv(template(args))."
         )
     elif isinstance(operation_list, qml.tape.QuantumTape):
-        operation_list.inv()
-        return operation_list
+        new_tape = operation_list.adjoint()
+        return new_tape
+
     elif not isinstance(operation_list, Iterable):
         raise ValueError("The provided operation_list is not iterable.")
 
@@ -334,13 +335,13 @@ def circuit2():
             # exist on the queuing context
             pass
 
-    with qml.tape.QuantumTape() as tape:
+    def qfunc():
         for o in operation_list:
             o.queue()
-            if o.inverse:
-                o.inv()
 
-    tape.inv()
+    with qml.tape.QuantumTape() as tape:
+        qml.adjoint(qfunc)()
+
     return tape
 
 

tests/devices/test_default_qubit.py

@@ -2054,7 +2054,7 @@ def test_s_inverse():
         test_s_inverse()
         operations = test_s_inverse.qtape.operations
         assert "S.inv" not in [i.name for i in operations]
-        assert "PhaseShift.inv" in [i.name for i in operations]
+        assert "PhaseShift" in [i.name for i in operations]
 
         expected = np.array([1.0, -1.0j]) / np.sqrt(2)
         assert np.allclose(dev.state, expected, atol=tol, rtol=0)

tests/ops/test_qubit_ops.py

@@ -421,7 +421,6 @@ def test_adjoint_with_decomposition(self, op_builder):
         "op",
         [
             qml.BasisState(np.array([0, 1]), wires=0),
-            qml.QubitStateVector(np.array([1.0, 0.0]), wires=0),
         ],
     )
     def test_adjoint_error_exception(self, op, tol):

tests/tape/test_tape.py

@@ -604,12 +604,12 @@ def test_inverse(self):
         tape.inv()
 
         # check that operation order is reversed
-        assert tape.operations == [prep] + ops[::-1]
+        assert [o.name for o in tape.operations] == [
+            o.name.replace(".inv", "") for o in [prep] + ops[::-1]
+        ]
 
         # check that operations are inverted
-        assert ops[0].inverse
-        assert not ops[1].inverse
-        assert ops[2].inverse
+        assert np.allclose(tape.operations[2].parameters, -np.array(p[-1:0:-1]))
 
         # check that parameter order has reversed
         assert tape.get_parameters() == [init_state, p[1], p[2], p[3], p[0]]
@@ -636,7 +636,7 @@ def test_parameter_transforms(self):
         tape.inv()
         assert tape.trainable_params == {1, 2}
         assert tape.get_parameters() == [p[0], p[1]]
-        assert tape._ops == ops
+        assert [o.name for o in tape._ops] == [o.name.replace(".inv", "") for o in ops]
 
 
 class TestExpand:

tests/templates/test_layers/test_particle_conserving_u1.py

@@ -84,7 +84,7 @@ def test_operations(self):
         assert gate_count == len(queue)
 
         # check initialization of the qubit register
-        assert isinstance(queue[0], qml.BasisState)
+        assert isinstance(queue[0], qml.templates.BasisEmbedding)
 
         # check all quantum operations
         idx_CRot = 8

tests/templates/test_layers/test_particle_conserving_u2.py

@@ -50,7 +50,7 @@ def test_operations(self, layers, qubits, init_state):
         assert len(queue) == n_gates
 
         # initialization
-        assert isinstance(queue[0], qml.BasisState)
+        assert isinstance(queue[0], qml.templates.BasisEmbedding)
 
         # order of gates
         for op1, op2 in zip(queue[1:], exp_gates):