Add transform to insert operations into circuits

doc/releases/changelog-dev.md

@@ -4,6 +4,38 @@
 
 <h3>New features since last release</h3>
 
+* The `insert` and `insert_in_dev` transforms have now been added,
+  providing a way to insert single-qubit operations into a quantum circuit.
+  [(#1795)](https://github.com/PennyLaneAI/pennylane/pull/1795)
+
+  The following QNode can be transformed to add noise to the circuit:
+
+  ```python
+  from pennylane.transforms import insert
+
+  dev = qml.device("default.mixed", wires=2)
+
+  @qml.qnode(dev)
+  @insert(qml.AmplitudeDamping, 0.2, position="end")
+  def f(w, x, y, z):
+      qml.RX(w, wires=0)
+      qml.RY(x, wires=1)
+      qml.CNOT(wires=[0, 1])
+      qml.RY(y, wires=0)
+      qml.RX(z, wires=1)
+      return qml.expval(qml.PauliZ(0) @ qml.PauliZ(1))
+  ```
+
+  Executions of this circuit will differ from the noise-free value:
+
+  ```pycon  
+  >>> f(0.9, 0.4, 0.5, 0.6)
+  tensor(0.754847, requires_grad=True)
+  >>> print(qml.draw(f)(0.9, 0.4, 0.5, 0.6))
+   0: ──RX(0.9)──╭C──RY(0.5)──AmplitudeDamping(0.2)──╭┤ ⟨Z ⊗ Z⟩ 
+   1: ──RY(0.4)──╰X──RX(0.6)──AmplitudeDamping(0.2)──╰┤ ⟨Z ⊗ Z⟩
+  ``` 
+
 * Common tape expansion functions are now available in `qml.transforms`,
   alongside a new `create_expand_fn` function for easily creating expansion functions
   from stopping criteria.
@@ -797,6 +829,6 @@
 
 This release contains contributions from (in alphabetical order):
 
-Utkarsh Azad, Akash Narayanan B, Sam Banning, Olivia Di Matteo, Andrew Gardhouse, David Ittah, Josh Izaac, Christina Lee,
+Utkarsh Azad, Akash Narayanan B, Sam Banning, Thomas Bromley, Olivia Di Matteo, Andrew Gardhouse, David Ittah, Josh Izaac, Christina Lee,
 Romain Moyard, Carrie-Anne Rubidge, Maria Schuld, Rishabh Singh, Ingrid Strandberg, Antal Száva, Cody Wang,
 David Wierichs, Moritz Willmann.

pennylane/transforms/__init__.py

@@ -49,6 +49,7 @@
     ~ctrl
     ~apply_controlled_Q
     ~quantum_monte_carlo
+    ~transforms.insert
 
 Transforms for circuit compilation
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -86,6 +87,17 @@
     ~transforms.measurement_grouping
     ~transforms.hamiltonian_expand
 
+Transforms that act on devices
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+These transforms apply to circuits just before they are
+executed on the device.
+
+.. autosummary::
+    :toctree: api
+
+    ~transforms.insert_in_dev
+
 Decorators and utility functions
 --------------------------------
 
@@ -117,6 +129,7 @@
 from .hamiltonian_expand import hamiltonian_expand
 from .measurement_grouping import measurement_grouping
 from .metric_tensor import metric_tensor
+from .insert_ops import insert, insert_in_dev
 from .optimization import (
     cancel_inverses,
     commute_controlled,

pennylane/transforms/insert_ops.py

@@ -0,0 +1,259 @@
+# Copyright 2021 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.
+"""
+Provides transforms for inserting operations into quantum circuits.
+"""
+from collections.abc import Sequence
+from copy import deepcopy
+from types import FunctionType
+from typing import Type, Union
+
+from pennylane import BasisState, Device, QubitStateVector, apply
+from pennylane.operation import Operation
+from pennylane.tape import QuantumTape
+from pennylane.transforms.qfunc_transforms import qfunc_transform, single_tape_transform
+
+
+@qfunc_transform
+@single_tape_transform
+def insert(
+    circuit: Union[callable, QuantumTape],
+    op: Union[callable, Type[Operation]],
+    op_args: Union[tuple, float],
+    position: str = "all",
+) -> Union[callable, QuantumTape]:
+    """Insert an operation into specified points in an input circuit.
+
+    The circuit will be updated to have the operation, specified by the ``op`` argument, added
+    according to the positioning specified in the ``position`` argument. Only single qubit
+    operations are permitted.
+
+    The type of ``op`` can be either a single operation or a quantum function. A quantum function
+    can be used to specify a sequence of operations acting on a single qubit, see the usage details
+    for more information.
+
+    Args:
+        circuit (callable or QuantumTape): the input circuit
+        op (callable or Type[Operation]): the single-qubit operation, or sequence of operations
+            acting on a single qubit, to be inserted into the circuit
+        op_args (tuple or float): the arguments fed to the operation, either as a tuple or a single
+            float
+        position (str): Specification of where to add the operation. Should be one of: ``"all"`` to
+            add the operation after all gates; ``"start"`` to add the operation to all wires
+            at the start of the circuit; ``"end"`` to add the operation to all wires at the
+            end of the circuit.
+
+    Returns:
+        callable or QuantumTape: the updated version of the input circuit
+
+    Raises:
+        ValueError: if a single operation acting on multiple wires is passed to ``op``
+        ValueError: if the requested ``position`` argument is not ``'start'``, ``'end'`` or
+            ``'all'``
+
+    **Example:**
+
+    The following QNode can be transformed to add noise to the circuit:
+
+    .. code-block:: python3
+
+        dev = qml.device("default.mixed", wires=2)
+
+        @qml.qnode(dev)
+        @qml.transforms.insert(qml.AmplitudeDamping, 0.2, position="end")
+        def f(w, x, y, z):
+            qml.RX(w, wires=0)
+            qml.RY(x, wires=1)
+            qml.CNOT(wires=[0, 1])
+            qml.RY(y, wires=0)
+            qml.RX(z, wires=1)
+            return qml.expval(qml.PauliZ(0) @ qml.PauliZ(1))
+
+    Executions of this circuit will differ from the noise-free value:
+
+    >>> f(0.9, 0.4, 0.5, 0.6)
+    tensor(0.754847, requires_grad=True)
+    >>> print(qml.draw(f)(0.9, 0.4, 0.5, 0.6))
+     0: ──RX(0.9)──╭C──RY(0.5)──AmplitudeDamping(0.2)──╭┤ ⟨Z ⊗ Z⟩
+     1: ──RY(0.4)──╰X──RX(0.6)──AmplitudeDamping(0.2)──╰┤ ⟨Z ⊗ Z⟩
+
+    .. UsageDetails::
+
+        **Specifying the operation as a quantum function:**
+
+        Instead of specifying ``op`` as a single :class:`~.Operation`, we can instead define a
+        quantum function. For example:
+
+        .. code-block:: python3
+
+            def op(x, y, wires):
+                qml.RX(x, wires=wires)
+                qml.PhaseShift(y, wires=wires)
+
+        This operation can be inserted into the following circuit:
+
+        .. code-block:: python3
+
+            dev = qml.device("default.qubit", wires=2)
+
+            @qml.qnode(dev)
+            @insert(op, [0.2, 0.3], position="end")
+            def f(w, x, y, z):
+                qml.RX(w, wires=0)
+                qml.RY(x, wires=1)
+                qml.CNOT(wires=[0, 1])
+                qml.RY(y, wires=0)
+                qml.RX(z, wires=1)
+                return qml.expval(qml.PauliZ(0) @ qml.PauliZ(1))
+
+        To check this, let's print out the circuit:
+
+        >>> print(qml.draw(f)(0.9, 0.4, 0.5, 0.6))
+         0: ──RX(0.9)──╭C──RY(0.5)──RX(0.2)──Rϕ(0.3)──╭┤ ⟨Z ⊗ Z⟩
+         1: ──RY(0.4)──╰X──RX(0.6)──RX(0.2)──Rϕ(0.3)──╰┤ ⟨Z ⊗ Z⟩
+
+        **Transforming tapes:**
+
+        Consider the following tape:
+
+        .. code-block:: python3
+
+            with qml.tape.QuantumTape() as tape:
+                qml.RX(0.9, wires=0)
+                qml.RY(0.4, wires=1)
+                qml.CNOT(wires=[0, 1])
+                qml.RY(0.5, wires=0)
+                qml.RX(0.6, wires=1)
+                qml.expval(qml.PauliZ(0) @ qml.PauliZ(1))
+
+        We can add the :class:`~.AmplitudeDamping` channel to the end of the circuit using:
+
+        >>> from pennylane.transforms import insert
+        >>> noisy_tape = insert(qml.AmplitudeDamping, 0.05, position="end")(tape)
+        >>> print(noisy_tape.draw())
+         0: ──RX(0.9)──╭C──RY(0.5)──AmplitudeDamping(0.05)──╭┤ ⟨Z ⊗ Z⟩
+         1: ──RY(0.4)──╰X──RX(0.6)──AmplitudeDamping(0.05)──╰┤ ⟨Z ⊗ Z⟩
+    """
+    if not isinstance(op, FunctionType) and op.num_wires != 1:
+        raise ValueError("Only single-qubit operations can be inserted into the circuit")
+    if position not in ("start", "end", "all"):
+        raise ValueError("Position must be either 'start', 'end', or 'all' (default)")
+
+    if not isinstance(op_args, Sequence):
+        op_args = [op_args]
+
+    num_preps = sum(isinstance(o, (QubitStateVector, BasisState)) for o in circuit.operations)
+
+    for i in range(num_preps):
+        apply(circuit.operations[i])
+
+    if position == "start":
+        for w in circuit.wires:
+            op(*op_args, wires=w)
+
+    for circuit_op in circuit.operations[num_preps:]:
+        apply(circuit_op)
+        if position == "all":
+            for w in circuit_op.wires:
+                op(*op_args, wires=w)
+
+    if position == "end":
+        for w in circuit.wires:
+            op(*op_args, wires=w)
+
+    for m in circuit.measurements:
+        apply(m)
+
+
+def insert_in_dev(
+    device: Device,
+    op: Union[callable, Type[Operation]],
+    op_args: Union[tuple, float],
+    position: str = "all",
+) -> Device:
+    """Insert an operation into specified points in circuits during device execution.
+
+    After applying this transform, circuits executed on the device will have operations inserted.
+    The operations are specified by the ``op`` argument and positioned according to the
+    ``position`` argument. Only single qubit operations are permitted.
+
+    The type of ``op`` can be either a single operation or a quantum function. A quantum function
+    can be used to specify a sequence of operations acting on a single qubit.
+
+    .. warning::
+
+        This device transform is a beta feature. Use the :class:`pennylane.beta.QNode` decorator to
+        create compatible QNodes and use :func:`~.execute` to execute quantum tapes.
+
+    Args:
+        device (Device): the device to be transformed
+        op (callable or Type[Operation]): the single-qubit operation, or sequence of operations
+            acting on a single qubit, to be inserted into circuits
+        op_args (tuple or float): the arguments fed to the operation, either as a tuple or a single
+            float
+        position (str): Specification of where to add the operation. Should be one of: ``"all"`` to
+            add the operation after all gates; ``"start"`` to add the operation to all wires
+            at the start of the circuit; ``"end"`` to add the operation to all wires at the
+            end of the circuit.
+
+    Returns:
+        Device: the updated device
+
+    Raises:
+        ValueError: if a single operation acting on multiple wires is passed to ``op``
+        ValueError: if the requested ``position`` argument is not ``'start'``, ``'end'`` or
+            ``'all'``
+
+    **Example:**
+
+    Consider the following QNode:
+
+    .. code-block:: python3
+
+        from pennylane.beta import qnode
+
+        dev = qml.device("default.mixed", wires=2)
+
+        @qnode(dev)
+        def f(w, x, y, z):
+            qml.RX(w, wires=0)
+            qml.RY(x, wires=1)
+            qml.CNOT(wires=[0, 1])
+            qml.RY(y, wires=0)
+            qml.RX(z, wires=1)
+            return qml.expval(qml.PauliZ(0) @ qml.PauliZ(1))
+
+    Execution of the circuit on ``dev`` will be noise-free:
+
+    >>> f(0.9, 0.4, 0.5, 0.6)
+    tensor(0.86243536, requires_grad=True)
+
+    However, noise can be easily added to the device:
+
+    >>> qml.transforms.insert_in_dev(dev, qml.AmplitudeDamping, 0.2)
+    >>> f(0.9, 0.4, 0.5, 0.6)
+    tensor(0.72945434, requires_grad=True)
+    """
+    # TODO: Remove warning in docstrings once new QNode replaces the old
+
+    new_dev = deepcopy(device)
+    original_expand_fn = new_dev.expand_fn
+
+    def new_expand_fn(circuit, max_expansion=10):
+        new_tape = insert(op, op_args, position)(circuit)
+        return original_expand_fn(new_tape, max_expansion=max_expansion)
+
+    new_dev.expand_fn = new_expand_fn
+
+    return new_dev

pennylane/transforms/qfunc_transforms.py

@@ -172,6 +172,9 @@ def __call__(self, tape, *args, **kwargs):
 def _create_qfunc_internal_wrapper(fn, tape_transform, transform_args, transform_kwargs):
     """Convenience function to create the internal wrapper function
     generated by the qfunc_transform decorator"""
+    if isinstance(fn, qml.tape.QuantumTape):
+        return tape_transform(fn, *transform_args, **transform_kwargs)
+
     if not callable(fn):
         raise ValueError(
             f"The qfunc to transform, {fn}, does not appear "