split_non_commuting transform for expectation values

pennylane/_device.py

@@ -729,6 +729,10 @@ def batch_transform(self, circuit):
                     "Can only return the expectation of a single Hamiltonian observable"
                 ) from e
 
+        if len(circuit._obs_sharing_wires) > 0 and not hamiltonian_in_obs:
+            # Check for case of non-commuting terms and that there are no Hamiltonians
+            return qml.transforms.split_non_commuting(circuit)
+
         # otherwise, return an identity transform
         return [circuit], lambda res: res[0]
 

pennylane/transforms/__init__.py

@@ -149,6 +149,7 @@
 
     ~transforms.measurement_grouping
     ~transforms.hamiltonian_expand
+    ~transforms.split_non_commuting
 
 Decorators and utility functions
 --------------------------------
@@ -186,6 +187,7 @@
 from .decompositions import zyz_decomposition, two_qubit_decomposition
 from .defer_measurements import defer_measurements
 from .hamiltonian_expand import hamiltonian_expand
+from .split_non_commuting import split_non_commuting
 from .measurement_grouping import measurement_grouping
 from .metric_tensor import metric_tensor
 from .adjoint_metric_tensor import adjoint_metric_tensor

pennylane/transforms/split_non_commuting.py

@@ -0,0 +1,115 @@
+# Copyright 2018-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.
+"""
+Contains the tape transform that splits non-commuting terms
+"""
+# pylint: disable=protected-access
+import pennylane as qml
+
+
+def split_non_commuting(tape):
+    r"""
+    Splits a tape measuring non-commuting observables into groups of commuting observables.
+
+    Args:
+        tape (.QuantumTape): the tape used when calculating the expectation value
+            of the Hamiltonian
+
+    Returns:
+        tuple[list[.QuantumTape], function]: Returns a tuple containing a list of
+        quantum tapes to be evaluated, and a function to be applied to these
+        tape executions to restore the ordering of the inputs.
+
+    **Example**
+
+    We can create a tape with non-commuting observables
+
+    .. code-block:: python3
+
+        import pennylane as qml
+        with qml.tape.QuantumTape() as tape:
+            qml.expval(qml.PauliZ(0))
+            qml.expval(qml.PauliY(0))
+        tapes, processing_fn = qml.transforms.split_non_commuting(tape)
+
+    Now ``tapes`` is a list of two tapes, each for one of the non-commuting terms.
+
+    >>> [t.observables for t in tapes]
+    [[expval(PauliZ(wires=[0]))], [expval(PauliY(wires=[0]))]]
+
+    The processing function becomes important when creating the commuting groups distorts the orde of the inputs.
+
+    .. code-block:: python3
+
+        with qml.tape.QuantumTape() as tape:
+            qml.expval(qml.PauliZ(0) @ qml.PauliZ(1))
+            qml.expval(qml.PauliX(0) @ qml.PauliX(1))
+            qml.expval(qml.PauliZ(0))
+            qml.expval(qml.PauliX(0))
+        tapes, processing_fn = qml.transforms.split_non_commuting(tape)
+
+    In this example, the groupings are ``group_coeffs = [[0,2], [1,3]]`` and processing_fn makes sure that the final output is of the same shape and ordering:
+
+    >>> processing_fn(tapes)
+    tensor([tensor(expval(PauliZ(wires=[0]) @ PauliZ(wires=[1])), dtype=object, requires_grad=True),
+        tensor(expval(PauliX(wires=[0]) @ PauliX(wires=[1])), dtype=object, requires_grad=True),
+        tensor(expval(PauliZ(wires=[0])), dtype=object, requires_grad=True),
+        tensor(expval(PauliX(wires=[0])), dtype=object, requires_grad=True)],
+       dtype=object, requires_grad=True)
+
+    """
+
+    measurements = tape.measurements
+
+    obs_list = []
+    # get the observables from the measurements
+    # TO DO: This loop should become superfluous when the reworked operator classes are implemented
+    for measurement in measurements:
+        if hasattr(measurement.obs, "obs"):
+            # this loop re-creates multi-qubit observables, e.g. PauliZ(0) @ PauliZ(1)
+            _list = (
+                measurement.obs.obs
+            )  # the list of individual observables before composition
+            obs = _list[0]
+            for ob_i in _list[1:]:
+                obs @= ob_i  # I am sure there must be a better way to do this?
+        else:
+            obs = measurement.obs
+        obs_list.append(obs)
+
+    # If there is more than one group of commuting observables, split tapes
+    groups, group_coeffs = qml.grouping.group_observables(obs_list, range(len(obs_list)))
+    if len(groups) > 1:
+        # make one tape per commuting group
+        tapes = []
+        for group in groups:
+            with tape.__class__() as new_tape:
+                [op.queue() for op in tape.operations]
+                [qml.expval(o) for o in group]
+
+            tapes.append(new_tape)
+
+        def reorder_fn(res):
+            """re-order the output to the original shape and order"""
+            res = qml.math.concatenate(res)
+            new_res = res.copy() # to keep the same format as res
+            reorder_indxs = qml.math.concatenate(group_coeffs)
+            for i,out in zip(reorder_indxs, res):
+                new_res[i] = out
+
+            return new_res
+
+        return tapes, reorder_fn
+    # if the group is already commuting, no need to do anything
+    return [tapes], lambda res: res[0]

tests/test_measurements.py

@@ -60,6 +60,25 @@ def test_ObservableReturnTypes(return_type, value):
     assert isinstance(return_type, qml.measurements.ObservableReturnTypes)
     assert repr(return_type) == value
 
+def test_expval_non_commuting_observables():
+    """Test expval with multiple non-commuting operators """
+    dev = qml.device("default.qubit", wires=5)
+
+    @qml.qnode(dev)
+    def circuit():
+        qml.Hadamard(1)
+        qml.Hadamard(0)
+        qml.PauliZ(0)
+        qml.Hadamard(3)
+        return [qml.expval(qml.PauliZ(0) @ qml.PauliZ(1)),
+        qml.expval(qml.PauliX(0)),
+        qml.expval(qml.PauliZ(1)),
+        qml.expval(qml.PauliX(1) @ qml.PauliX(4)),
+        qml.expval(qml.PauliX(3))]
+
+    assert all(np.isclose(circuit(),np.array([0., -1., 0., 0., 1.])))
+
+
 
 def test_no_measure(tol):
     """Test that failing to specify a measurement