Daily rc sync to master 2022-04-25

.github/workflows/upload.yml

@@ -123,6 +123,7 @@ jobs:
           pip install -r requirements-ci.txt
           python setup.py bdist_wheel
           pip install dist/PennyLane*.whl
+
       - name: Run tests
         run: |
           python -m pytest pennylane/devices/tests \

doc/code/qml_qchem.rst

@@ -190,7 +190,7 @@ The :func:`~.molecular_hamiltonian` function can be also used to construct the m
 with a non-differentiable backend that uses the
 `OpenFermion-PySCF <https://github.com/quantumlib/OpenFermion-PySCF>`_ plugin interfaced with the
 electronic structure package `PySCF <https://github.com/sunqm/pyscf>`_. The non-differentiable
-backend can be selected by setting `method='pyscf'` in :func:`~.molecular_hamiltonian`:
+backend can be selected by setting ``method='pyscf'`` in :func:`~.molecular_hamiltonian`:
 
 .. code-block:: python
 

doc/introduction/chemistry.rst

@@ -6,7 +6,8 @@ contains a differentiable Hartree-Fock solver and the functionality to construct
 fully-differentiable molecular Hamiltonian that can be used as input to quantum algorithms
 such as the variational quantum eigensolver (VQE) algorithm. The :mod:`~.qchem` module
 also provides tools for building other observables such as molecular dipole moment, spin
-and particle number observables.
+and particle number observables. The theoretical foundation of the quantum chemistry functionality
+in PennyLane is explained in our `white paper <https://arxiv.org/abs/2111.09967>`_.
 
 Building the electronic Hamiltonian
 -----------------------------------
@@ -34,7 +35,7 @@ with an external backend that uses the
 `OpenFermion-PySCF <https://github.com/quantumlib/OpenFermion-PySCF>`_ plugin interfaced with the
 electronic structure package `PySCF <https://github.com/sunqm/pyscf>`_, which requires separate
 installation. This backend is non-differentiable and can be selected by setting
-`method='pyscf'` in :func:`~.molecular_hamiltonian`.
+``method='pyscf'`` in :func:`~.molecular_hamiltonian`.
 
 Furthermore, the net charge,
 the `spin multiplicity <https://en.wikipedia.org/wiki/Multiplicity_(chemistry)>`_, the
@@ -73,7 +74,7 @@ where a quantum computer is used to prepare the trial wave function of a molecul
 the expectation value of the *electronic Hamiltonian*, while a classical optimizer is used to
 find its ground state.
 
-PennyLane supports treating Hamiltonians just like any other observable, and the 
+PennyLane supports treating Hamiltonians just like any other observable, and the
 expectation value of a Hamiltonian can be calculated using ``qml.expval``:
 
 .. code-block:: python

doc/introduction/measurements.rst

@@ -77,7 +77,7 @@ by a ``Hadamard`` and ``CNOT`` gate.
     import pennylane as qml
     from pennylane import numpy as np
 
-    dev = qml.device("default.qubit", wires=2)
+    dev = qml.device("default.qubit", wires=2, shots=1000)
 
     @qml.qnode(dev)
     def circuit():
@@ -130,7 +130,7 @@ Probability
 
 You can also train QNodes on computational basis probabilities, by using
 the :func:`~.pennylane.probs` measurement function. The function can
-accept either specified ``wires`` or an observable that rotates the 
+accept either specified ``wires`` or an observable that rotates the
 computational basis.
 
 .. code-block:: python3

pennylane/interfaces/autograd.py

@@ -229,7 +229,15 @@ def grad_fn(dy):
 
                 vjps = [qml.gradients.compute_vjp(d, jac) for d, jac in zip(dy, jacs)]
 
-        return [qml.math.to_numpy(v, max_depth=_n) if isinstance(v, ArrayBox) else v for v in vjps]
+        return_vjps = [
+            qml.math.to_numpy(v, max_depth=_n) if isinstance(v, ArrayBox) else v for v in vjps
+        ]
+        if device.capabilities().get("provides_jacobian", False):
+            # in the case where the device provides the jacobian,
+            # the output of grad_fn must be wrapped in a tuple in
+            # order to match the input parameters to _execute.
+            return (return_vjps,)
+        return return_vjps
 
     return grad_fn
 

pennylane/interfaces/execution.py

@@ -21,6 +21,9 @@
 # pylint: disable=import-outside-toplevel,too-many-arguments,too-many-branches,not-callable
 from functools import wraps
 import itertools
+import warnings
+import inspect
+from contextlib import _GeneratorContextManager
 from cachetools import LRUCache
 
 import pennylane as qml
@@ -119,6 +122,33 @@ def wrapper(tapes, **kwargs):
             if hashes[i] in cache:
                 # Tape exists within the cache, store the cached result
                 cached_results[i] = cache[hashes[i]]
+
+                # Introspect the set_shots decorator of the input function:
+                #   warn the user in case of finite shots with cached results
+                finite_shots = False
+
+                closure = inspect.getclosurevars(fn).nonlocals
+                if "original_fn" in closure:  # deal with expand_fn wrapper above
+                    closure = inspect.getclosurevars(closure["original_fn"]).nonlocals
+
+                # retrieve the captured context manager instance (for set_shots)
+                if "self" in closure and isinstance(closure["self"], _GeneratorContextManager):
+                    # retrieve the shots from the arguments or device instance
+                    if closure["self"].func.__name__ == "set_shots":
+                        dev, shots = closure["self"].args
+                        shots = dev.shots if shots is False else shots
+                        finite_shots = isinstance(shots, int)
+
+                if finite_shots:
+                    warnings.warn(
+                        "Cached execution with finite shots detected!\n"
+                        "Note that samples as well as all noisy quantities computed via sampling "
+                        "will be identical across executions. This situation arises where tapes "
+                        "are executed with identical operations, measurements, and parameters.\n"
+                        "To avoid this behavior, provide 'cache=False' to the QNode or execution "
+                        "function.",
+                        UserWarning,
+                    )
             else:
                 # Tape does not exist within the cache, store the tape
                 # for execution via the execution function.

pennylane/measurements.py

@@ -28,7 +28,6 @@
 import numpy as np
 
 import pennylane as qml
-from pennylane.operation import Observable
 from pennylane.wires import Wires
 
 # =============================================================================
@@ -494,7 +493,7 @@ def circuit(x):
     Raises:
         QuantumFunctionError: `op` is not an instance of :class:`~.Observable`
     """
-    if not isinstance(op, (Observable, qml.Hamiltonian)):
+    if not isinstance(op, (qml.operation.Observable, qml.Hamiltonian)):
         raise qml.QuantumFunctionError(
             f"{op.name} is not an observable: cannot be used with expval"
         )
@@ -529,7 +528,7 @@ def circuit(x):
     Raises:
         QuantumFunctionError: `op` is not an instance of :class:`~.Observable`
     """
-    if not isinstance(op, Observable):
+    if not isinstance(op, qml.operation.Observable):
         raise qml.QuantumFunctionError(f"{op.name} is not an observable: cannot be used with var")
 
     return MeasurementProcess(Variance, obs=op, shape=(1,), numeric_type=float)
@@ -607,7 +606,9 @@ def circuit(x):
         case ``qml.sample(obs)`` is interpreted as a single-shot expectation value of the
         observable ``obs``.
     """
-    if not isinstance(op, Observable) and op is not None:  # None type is also allowed for op
+    if (
+        not isinstance(op, qml.operation.Observable) and op is not None
+    ):  # None type is also allowed for op
         raise qml.QuantumFunctionError(
             f"{op.name} is not an observable: cannot be used with sample"
         )

pennylane/operation.py

@@ -110,6 +110,20 @@
 from .utils import pauli_eigs
 
 
+def __getattr__(name):
+    # for more information on overwriting `__getattr__`, see https://peps.python.org/pep-0562/
+    warning_names = {"Sample", "Variance", "Expectation", "Probability", "State", "MidMeasure"}
+    if name in warning_names:
+        obj = getattr(qml.measurements, name)
+        warning_string = f"qml.operation.{name} is deprecated. Please import from qml.measurements.{name} instead"
+        warnings.warn(warning_string, UserWarning)
+        return obj
+    try:
+        return globals()[name]
+    except KeyError as e:
+        raise AttributeError from e
+
+
 def expand_matrix(base_matrix, wires, wire_order):
     """Re-express a base matrix acting on a subspace defined by a set of wire labels
     according to a global wire order.

pennylane/transforms/control.py

@@ -188,7 +188,8 @@ def ctrl(fn, control, control_values=None):
     Args:
         fn (function): Any python function that applies pennylane operations.
         control (Wires): The control wire(s).
-        control_values (list[int]): The values the control wire(s) should take.
+        control_values (int or list[int]): The value(s) the control wire(s) should take.
+            Integers other than 0 or 1 will be treated as ``int(bool(x))``.
 
     Returns:
         function: A new function that applies the controlled equivalent of ``fn``. The returned
@@ -240,7 +241,7 @@ def my_circuit2():
 
     .. Note::
 
-        Some devices are able to take advantage of the inherient sparsity of a
+        Some devices are able to take advantage of the inherent sparsity of a
         controlled operation. In those cases, it may be more efficient to use
         this transform rather than adding controls by hand. For devices that don't
         have special control support, the operation is expanded to add control wires
@@ -255,25 +256,25 @@ def my_circuit2():
         .. code-block:: python3
 
             # These two ops are equivalent.
-            op1 = qml.ctrl(qml.ctrl(my_ops, 1), 2)
-            op2 = qml.ctrl(my_ops, [2, 1])
+            op1 = qml.ctrl(qml.ctrl(ops, 1), 2)
+            op2 = qml.ctrl(ops, [2, 1])
 
         **Control Value Assignment**
 
         Control values can be assigned as follows.
 
         .. code-block:: python3
 
-            op = qml.ctrl(qml.ctrl(my_ops, 1), 2, control_values=0)
-            op()
+            op = qml.ctrl(ops, 2, control_values=0)
+            op(params=[0.1, 0.2])
 
         This is equivalent to the following.
 
         .. code-block:: python3
 
             qml.PauliX(wires=2)
-            op = qml.ctrl(qml.ctrl(my_ops, 1), 2)
-            op()
+            op = qml.ctrl(ops, 2)
+            op(params=[0.1, 0.2])
             qml.PauliX(wires=2)
 
     """

pennylane/transforms/qcut.py

@@ -967,7 +967,7 @@ def cut_circuit_mc(
     Args:
         tape (QuantumTape): the tape of the full circuit to be cut
         classical_processing_fn (callable): A classical postprocessing function to be applied to
-            the reconstructed bitstrings. The expected input is a bitstring; a flat array of length ``wires``.
+            the reconstructed bitstrings. The expected input is a bitstring; a flat array of length ``wires``,
             and the output should be a single number within the interval :math:`[-1, 1]`.
             If not supplied, the transform will output samples.
         auto_cutter (Union[bool, Callable]): Toggle for enabling automatic cutting with the default
@@ -1093,6 +1093,8 @@ def circuit(x):
 
         .. code-block:: python
 
+            np.random.seed(42)
+
             with qml.tape.QuantumTape() as tape:
                 qml.Hadamard(wires=0)
                 qml.CNOT(wires=[0, 1])
@@ -1126,9 +1128,9 @@ def circuit(x):
                 qml.sample(wires=[0, 1, 2])
 
         >>> cut_graph = qml.transforms.qcut.find_and_place_cuts(
-                graph=qml.transforms.qcut.tape_to_graph(uncut_tape),
-                cut_strategy=qml.transforms.qcut.CutStrategy(max_free_wires=2),
-            )
+        ...     graph=qml.transforms.qcut.tape_to_graph(uncut_tape),
+        ...     cut_strategy=qml.transforms.qcut.CutStrategy(max_free_wires=2),
+        ... )
         >>> print(qml.transforms.qcut.graph_to_tape(cut_graph).draw())
          0: ──H─╭C───────────┤  Sample[|1⟩⟨1|]
          1: ────╰X──//──X─╭C─┤  Sample[|1⟩⟨1|]
@@ -1187,11 +1189,11 @@ def circuit(x):
 
         >>> shots = 3
         >>> configurations, settings = qml.transforms.qcut.expand_fragment_tapes_mc(
-        ...        fragment_tapes, communication_graph, shots=shots
-        ...    )
+        ...     fragment_tapes, communication_graph, shots=shots
+        ... )
         >>> tapes = tuple(tape for c in configurations for tape in c)
         >>> settings
-        tensor([[0, 4, 7]], requires_grad=True)
+        tensor([[6, 3, 4]], requires_grad=True)
 
         Each configuration is drawn below:
 
@@ -1202,21 +1204,21 @@ def circuit(x):
         .. code-block::
 
             0: ──H─╭C────┤  Sample[|1⟩⟨1|]
-            1: ────╰X──X─┤  Sample[I]
+            1: ────╰X──X─┤  Sample[Z]
 
             0: ──H─╭C────┤  Sample[|1⟩⟨1|]
-            1: ────╰X──X─┤  Sample[Y]
+            1: ────╰X──X─┤  Sample[X]
 
             0: ──H─╭C────┤  Sample[|1⟩⟨1|]
-            1: ────╰X──X─┤  Sample[Z]
+            1: ────╰X──X─┤  Sample[Y]
 
             0: ──I─╭C─┤  Sample[|1⟩⟨1|]
             1: ────╰X─┤  Sample[|1⟩⟨1|]
 
-            0: ──H──S─╭C─┤  Sample[|1⟩⟨1|]
+            0: ──X──S─╭C─┤  Sample[|1⟩⟨1|]
             1: ───────╰X─┤  Sample[|1⟩⟨1|]
 
-            0: ──X─╭C─┤  Sample[|1⟩⟨1|]
+            0: ──H─╭C─┤  Sample[|1⟩⟨1|]
             1: ────╰X─┤  Sample[|1⟩⟨1|]
 
         The last step is to execute the tapes and postprocess the results using
@@ -1229,9 +1231,9 @@ def circuit(x):
         ...     communication_graph,
         ...     shots=shots,
         ... )
-        [array([[1., 0., 0.],
-                [0., 0., 0.],
-                [1., 1., 1.]])]
+        [array([[0., 0., 0.],
+                [1., 0., 0.],
+                [1., 0., 0.]])]
 
         Alternatively, it is possible to calculate an expectation value if a classical
         processing function is provided that will accept the reconstructed circuit bitstrings
@@ -1252,7 +1254,7 @@ def fn(x):
         ...     shots,
         ...     fn
         ... )
-        array(4.)
+        array(-4.)
     """
     # pylint: disable=unused-argument, too-many-arguments
 

tests/interfaces/test_autograd.py

@@ -21,6 +21,7 @@
 from pennylane import numpy as np
 
 import pennylane as qml
+from pennylane.devices import DefaultQubit
 from pennylane.gradients import finite_diff, param_shift
 from pennylane.interfaces import execute
 
@@ -1111,3 +1112,30 @@ def test_multiple_hamiltonians_trainable(self, cost_fn, execute_kwargs, tol):
         res = np.hstack(qml.jacobian(cost_fn)(weights, coeffs1, coeffs2, dev=dev))
         expected = self.cost_fn_jacobian(weights, coeffs1, coeffs2)
         assert np.allclose(res, expected, atol=tol, rtol=0)
+
+
+class TestCustomJacobian:
+    def test_custom_jacobians(self):
+        class CustomJacobianDevice(DefaultQubit):
+            @classmethod
+            def capabilities(cls):
+                capabilities = super().capabilities()
+                capabilities["provides_jacobian"] = True
+                return capabilities
+
+            def jacobian(self, tape):
+                return np.array([1.0, 2.0, 3.0, 4.0])
+
+        dev = CustomJacobianDevice(wires=2)
+
+        @qml.qnode(dev, diff_method="device")
+        def circuit(v):
+            qml.RX(v, wires=0)
+            return qml.probs(wires=[0, 1])
+
+        d_circuit = qml.jacobian(circuit, argnum=0)
+
+        params = np.array(1.0, requires_grad=True)
+
+        d_out = d_circuit(params)
+        assert np.allclose(d_out, np.array([1.0, 2.0, 3.0, 4.0]))

tests/test_operation.py

@@ -33,6 +33,16 @@
 # pylint: disable=no-self-use, no-member, protected-access, pointless-statement
 
 
+@pytest.mark.parametrize(
+    "return_type", ("Sample", "Variance", "Expectation", "Probability", "State", "MidMeasure")
+)
+def test_obersvablereturntypes_import_warnings(return_type):
+    """Test that accessing the observable return types through qml.operation emit a warning."""
+
+    with pytest.warns(UserWarning, match=r"is deprecated"):
+        getattr(qml.operation, return_type)
+
+
 class TestOperatorConstruction:
     """Test custom operators construction."""