Pennylane

<h3>New features since last release</h3>

<h4>New machine learning integrations</h4>

* PennyLane QNodes can now be converted into Keras layers, allowing for creation of quantum and hybrid models using the Keras API. [(529)](https://github.com/XanaduAI/pennylane/pull/529)

A PennyLane QNode can be converted into a Keras layer using the `KerasLayer` class:

python
from pennylane.qnn import KerasLayer

qml.qnode(dev)
def circuit(inputs, weights_0, weight_1):
define the circuit
...

weight_shapes = {"weights_0": 3, "weight_1": 1}
qlayer = qml.qnn.KerasLayer(circuit, weight_shapes, output_dim=2)


A hybrid model can then be easily constructed:

python
model = tf.keras.models.Sequential([qlayer, tf.keras.layers.Dense(2)])


* Added a new type of QNode, `qml.qnodes.PassthruQNode`. For simulators which are coded in an external library which supports automatic differentiation, PennyLane will treat a PassthruQNode as a "white box", and rely on the external library to directly provide gradients via backpropagation. This can be more efficient than the using parameter-shift rule for a large number of parameters. [(488)](https://github.com/XanaduAI/pennylane/pull/488)

Currently this behaviour is supported by PennyLane's `default.tensor.tf` device backend, compatible with the `'tf'` interface using TensorFlow 2:

python
dev = qml.device('default.tensor.tf', wires=2)

qml.qnode(dev, diff_method="backprop")
def circuit(params):
qml.RX(params[0], wires=0)
qml.RX(params[1], wires=1)
qml.CNOT(wires=[0, 1])
return qml.expval(qml.PauliZ(0))

qnode = PassthruQNode(circuit, dev)
params = tf.Variable([0.3, 0.1])

with tf.GradientTape() as tape:
tape.watch(params)
res = qnode(params)

grad = tape.gradient(res, params)


<h4>New optimizers</h4>

* Added the `qml.RotosolveOptimizer`, a gradient-free optimizer that minimizes the quantum function by updating each parameter, one-by-one, via a closed-form expression while keeping other parameters fixed.
[(636)](https://github.com/XanaduAI/pennylane/pull/636) [(#539)](https://github.com/XanaduAI/pennylane/pull/539)

* Added the `qml.RotoselectOptimizer`, which uses Rotosolve to minimizes a quantum function with respect to both the
rotation operations applied and the rotation parameters. [(636)](https://github.com/XanaduAI/pennylane/pull/636) [(#539)](https://github.com/XanaduAI/pennylane/pull/539)

For example, given a quantum function `f` that accepts parameters `x` and a list of corresponding rotation operations `generators`, the Rotoselect optimizer will, at each step, update both the parameter values and the list of rotation gates to minimize the loss:

pycon
>>> opt = qml.optimize.RotoselectOptimizer()
>>> x = [0.3, 0.7]
>>> generators = [qml.RX, qml.RY]
>>> for _ in range(100):
... x, generators = opt.step(f, x, generators)



<h4>New operations</h4>

* Added the `PauliRot` gate, which performs an arbitrary Pauli rotation on multiple qubits, and the `MultiRZ` gate,
which performs a rotation generated by a tensor product of Pauli Z operators. [(559)](https://github.com/XanaduAI/pennylane/pull/559)

python
dev = qml.device('default.qubit', wires=4)

qml.qnode(dev)
def circuit(angle):
qml.PauliRot(angle, "IXYZ", wires=[0, 1, 2, 3])
return [qml.expval(qml.PauliZ(wire)) for wire in [0, 1, 2, 3]]


pycon
>>> circuit(0.4)
[1. 0.92106099 0.92106099 1. ]
>>> print(circuit.draw())
0: ──╭RI(0.4)──┤ ⟨Z⟩
1: ──├RX(0.4)──┤ ⟨Z⟩
2: ──├RY(0.4)──┤ ⟨Z⟩
3: ──╰RZ(0.4)──┤ ⟨Z⟩


If the `PauliRot` gate is not supported on the target device, it will be decomposed into `Hadamard`, `RX` and `MultiRZ` gates. Note that identity gates in the Pauli word result in untouched wires:

pycon
>>> print(circuit.draw())
0: ───────────────────────────────────┤ ⟨Z⟩
1: ──H──────────╭RZ(0.4)──H───────────┤ ⟨Z⟩
2: ──RX(1.571)──├RZ(0.4)──RX(-1.571)──┤ ⟨Z⟩
3: ─────────────╰RZ(0.4)──────────────┤ ⟨Z⟩


If the `MultiRZ` gate is not supported, it will be decomposed into
`CNOT` and `RZ` gates:

pycon
>>> print(circuit.draw())
0: ──────────────────────────────────────────────────┤ ⟨Z⟩
1: ──H──────────────╭X──RZ(0.4)──╭X──────H───────────┤ ⟨Z⟩
2: ──RX(1.571)──╭X──╰C───────────╰C──╭X──RX(-1.571)──┤ ⟨Z⟩
3: ─────────────╰C───────────────────╰C──────────────┤ ⟨Z⟩


* PennyLane now provides `DiagonalQubitUnitary` for diagonal gates, that are e.g., encountered in IQP circuits. These kinds of gates can be evaluated much faster on a simulator device. [(567)](https://github.com/XanaduAI/pennylane/pull/567)

The gate can be used, for example, to efficiently simulate oracles:

python
dev = qml.device('default.qubit', wires=3)

Function as a bitstring
f = np.array([1, 0, 0, 1, 1, 0, 1, 0])

qml.qnode(dev)
def circuit(weights1, weights2):
qml.templates.StronglyEntanglingLayers(weights1, wires=[0, 1, 2])

Implements the function as a phase-kickback oracle
qml.DiagonalQubitUnitary((-1)**f, wires=[0, 1, 2])

qml.templates.StronglyEntanglingLayers(weights2, wires=[0, 1, 2])
return [qml.expval(qml.PauliZ(w)) for w in range(3)]


* Added the `TensorN` CVObservable that can represent the tensor product of the `NumberOperator` on photonic backends. [(608)](https://github.com/XanaduAI/pennylane/pull/608)

<h4>New templates</h4>

* Added the `ArbitraryUnitary` and `ArbitraryStatePreparation` templates, which use `PauliRot` gates to perform an arbitrary unitary and prepare an arbitrary basis state with the minimal number of parameters. [(590)](https://github.com/XanaduAI/pennylane/pull/590)

python
dev = qml.device('default.qubit', wires=3)

qml.qnode(dev)
def circuit(weights1, weights2):
qml.templates.ArbitraryStatePreparation(weights1, wires=[0, 1, 2])
qml.templates.ArbitraryUnitary(weights2, wires=[0, 1, 2])
return qml.probs(wires=[0, 1, 2])


* Added the `IQPEmbedding` template, which encodes inputs into the diagonal gates of an IQP circuit. [(605)](https://github.com/XanaduAI/pennylane/pull/605)

<img src="https://pennylane.readthedocs.io/en/latest/_images/iqp.png"
width=50%></img>

* Added the ``SimplifiedTwoDesign`` template, which implements the circuit design of [Cerezo et al. (2020)](<https://arxiv.org/abs/2001.00550>). [(#556)](https://github.com/XanaduAI/pennylane/pull/556)

<img src="https://pennylane.readthedocs.io/en/latest/_images/simplified_two_design.png"
width=50%></img>

* Added the ``BasicEntanglerLayers`` template, which is a simple layer architecture of rotations and CNOT nearest-neighbour entanglers. [(555)](https://github.com/XanaduAI/pennylane/pull/555)

<img src="https://pennylane.readthedocs.io/en/latest/_images/basic_entangler.png" width=50%></img>

* PennyLane now offers a broadcasting function to easily construct templates: `qml.broadcast()` takes single quantum operations or other templates and applies them to wires in a specific pattern. [(515)](https://github.com/XanaduAI/pennylane/pull/515) [(#522)](https://github.com/XanaduAI/pennylane/pull/522) [(#526)](https://github.com/XanaduAI/pennylane/pull/526) [(#603)](https://github.com/XanaduAI/pennylane/pull/603)

For example, we can use broadcast to repeat a custom template across multiple wires:

python
from pennylane.templates import template

template
def mytemplate(pars, wires):
qml.Hadamard(wires=wires)
qml.RY(pars, wires=wires)

dev = qml.device('default.qubit', wires=3)

qml.qnode(dev)
def circuit(pars):
qml.broadcast(mytemplate, pattern="single", wires=[0,1,2], parameters=pars)
return qml.expval(qml.PauliZ(0))


pycon
>>> circuit([1, 1, 0.1])
-0.841470984807896
>>> print(circuit.draw())
0: ──H──RY(1.0)──┤ ⟨Z⟩
1: ──H──RY(1.0)──┤
2: ──H──RY(0.1)──┤


For other available patterns, see the [broadcast function documentation](https://pennylane.readthedocs.io/en/latest/code/api/pennylane.broadcast.html).

<h3>Breaking changes</h3>

* The `QAOAEmbedding` now uses the new `MultiRZ` gate as a `ZZ` entangler, which changes the convention. While previously, the `ZZ` gate in the embedding was implemented as

python
CNOT(wires=[wires[0], wires[1]])
RZ(2 * parameter, wires=wires[0])
CNOT(wires=[wires[0], wires[1]])


the `MultiRZ` corresponds to

python
CNOT(wires=[wires[1], wires[0]])
RZ(parameter, wires=wires[0])
CNOT(wires=[wires[1], wires[0]])


which differs in the factor of `2`, and fixes a bug in the wires that the `CNOT` was applied to. [(609)](https://github.com/XanaduAI/pennylane/pull/609)

* Probability methods are handled by `QubitDevice` and device method requirements are modified to simplify plugin development. [(573)](https://github.com/XanaduAI/pennylane/pull/573)

* The internal variables `All` and `Any` to mark an `Operation` as acting on all or any wires have been renamed to `AllWires` and `AnyWires`. [(614)](https://github.com/XanaduAI/pennylane/pull/614)

<h3>Improvements</h3>

* Improvements to the speed/performance of the `default.qubit` device. [(567)](https://github.com/XanaduAI/pennylane/pull/567) [(#559)](https://github.com/XanaduAI/pennylane/pull/559)

* Added the `"backprop"` and `"device"` differentiation methods to the `qnode` decorator. [(552)](https://github.com/XanaduAI/pennylane/pull/552)

- `"backprop"`: Use classical backpropagation. Default on simulator devices that are classically end-to-end differentiable.
The returned QNode can only be used with the same machine learning framework (e.g., ``default.tensor.tf`` simulator with the ``tensorflow`` interface).

- `"device"`: Queries the device directly for the gradient.

Using the `"backprop"` differentiation method with the `default.tensor.tf` device, the created QNode is a 'white-box', and is tightly integrated with the overall TensorFlow computation:

python
>>> dev = qml.device("default.tensor.tf", wires=1)
>>> qml.qnode(dev, interface="tf", diff_method="backprop")
>>> def circuit(x):
... qml.RX(x[1], wires=0)
... qml.Rot(x[0], x[1], x[2], wires=0)
... return qml.expval(qml.PauliZ(0))
>>> vars = tf.Variable([0.2, 0.5, 0.1])
>>> with tf.GradientTape() as tape:
... res = circuit(vars)
>>> tape.gradient(res, vars)
<tf.Tensor: shape=(3,), dtype=float32, numpy=array([-2.2526717e-01, -1.0086454e+00, 1.3877788e-17], dtype=float32)>


* The circuit drawer now displays inverted operations, as well as wires where probabilities are returned from the device: [(540)](https://github.com/XanaduAI/pennylane/pull/540)

python
>>> qml.qnode(dev)
... def circuit(theta):
... qml.RX(theta, wires=0)
... qml.CNOT(wires=[0, 1])
... qml.S(wires=1).inv()
... return qml.probs(wires=[0, 1])
>>> circuit(0.2)
array([0.99003329, 0. , 0. , 0.00996671])
>>> print(circuit.draw())
0: ──RX(0.2)──╭C───────╭┤ Probs
1: ───────────╰X──S⁻¹──╰┤ Probs


* You can now evaluate the metric tensor of a VQE Hamiltonian via the new `VQECost.metric_tensor` method. This allows `VQECost` objects to be directly optimized by the quantum natural gradient optimizer (`qml.QNGOptimizer`). [(618)](https://github.com/XanaduAI/pennylane/pull/618)

* The input check functions in `pennylane.templates.utils` are now public and visible in the API documentation. [(566)](https://github.com/XanaduAI/pennylane/pull/566)

* Added keyword arguments for step size and order to the `qnode` decorator, as well as the `QNode` and `JacobianQNode` classes. This enables the user to set the step size and order when using finite difference methods. These options are also exposed when creating QNode collections. [(530)](https://github.com/XanaduAI/pennylane/pull/530) [(#585)](https://github.com/XanaduAI/pennylane/pull/585) [(#587)](https://github.com/XanaduAI/pennylane/pull/587)

* The decomposition for the `CRY` gate now uses the simpler form `RY CNOT RY CNOT` [(547)](https://github.com/XanaduAI/pennylane/pull/547)

* The underlying queuing system was refactored, removing the `qml._current_context` property that held the currently active `QNode` or `OperationRecorder`. Now, all objects that expose a queue for operations inherit from `QueuingContext` and
register their queue globally. [(548)](https://github.com/XanaduAI/pennylane/pull/548)

* The PennyLane repository has a new benchmarking tool which supports the comparison of different git revisions. [(568)](https://github.com/XanaduAI/pennylane/pull/568) [(#560)](https://github.com/XanaduAI/pennylane/pull/560) [(#516)](https://github.com/XanaduAI/pennylane/pull/516)

<h3>Documentation</h3>

* Updated the development section by creating a landing page with links to sub-pages containing specific guides. [(596)](https://github.com/XanaduAI/pennylane/pull/596)

* Extended the developer's guide by a section explaining how to add new templates. [(564)](https://github.com/XanaduAI/pennylane/pull/564)

<h3>Bug fixes</h3>

* `tf.GradientTape().jacobian()` can now be evaluated on QNodes using the TensorFlow interface. [(626)](https://github.com/XanaduAI/pennylane/pull/626)

* `RandomLayers()` is now compatible with the qiskit devices. [(597)](https://github.com/XanaduAI/pennylane/pull/597)

* `DefaultQubit.probability()` now returns the correct probability when called with `device.analytic=False`. [(563)](https://github.com/XanaduAI/pennylane/pull/563)

* Fixed a bug in the `StronglyEntanglingLayers` template, allowing it to work correctly when applied to a single wire. [(544)](https://github.com/XanaduAI/pennylane/pull/544)

* Fixed a bug when inverting operations with decompositions; operations marked as inverted are now correctly inverted when the fallback decomposition is called. [(543)](https://github.com/XanaduAI/pennylane/pull/543)

* The `QNode.print_applied()` method now correctly displays wires where `qml.prob()` is being returned. [542](https://github.com/XanaduAI/pennylane/pull/542)

<h3>Contributors</h3>

This release contains contributions from (in alphabetical order):

Ville Bergholm, Lana Bozanic, Thomas Bromley, Theodor Isacsson, Josh Izaac, Nathan Killoran, Maggie Li, Johannes Jakob Meyer, Maria Schuld, Sukin Sim, Antal Száva.

Improvements

* Beginning of support for Python 3.8, with the test suite now being run in a Python 3.8 environment. [(501)](https://github.com/XanaduAI/pennylane/pull/501)

Documentation

* Present templates as a gallery of thumbnails showing the basic circuit architecture. [(499)](https://github.com/XanaduAI/pennylane/pull/499)

Bug fixes

* Fixed a bug where multiplying a QNode parameter by 0 caused a divide by zero error when calculating the parameter shift formula. [(512)](https://github.com/XanaduAI/pennylane/pull/512)

* Fixed a bug where the shape of differentiable QNode arguments was being cached on the first construction, leading to indexing errors if the QNode was re-evaluated if the argument changed shape. [(505)](https://github.com/XanaduAI/pennylane/pull/505)

Contributors

This release contains contributions from (in alphabetical order):

Ville Bergholm, Josh Izaac, Maria Schuld, Antal Száva.

_See the [release notes](https://pennylane.readthedocs.io/en/stable/development/release_notes.html) on the PennyLane website for code examples and more details._

New features since last release

* Added a quantum chemistry package, `pennylane.qchem`, which supports integration with OpenFermion, Psi4, PySCF, and OpenBabel. Functions and classes for creating and solving VQE
problems have also been addded. [(453)](https://github.com/XanaduAI/pennylane/pull/453) [(#467)](https://github.com/XanaduAI/pennylane/pull/467)

Features include:

- Generate the qubit Hamiltonians directly starting with the atomic structure of the molecule.
- Calculate the mean-field (Hartree-Fock) electronic structure of molecules.
- Allow to define an active space based on the number of active electrons and active orbitals.
- Perform the fermionic-to-qubit transformation of the electronic Hamiltonian by
using different functions implemented in OpenFermion.
- Convert OpenFermion's QubitOperator to a Pennylane `Hamiltonian` class.
- Perform a Variational Quantum Eigensolver (VQE) computation with this Hamiltonian in PennyLane.
- `qml.Hamiltonian`: a lightweight class for representing qubit Hamiltonians
- `qml.VQECost`: a class for quickly constructing a differentiable cost function
given a circuit ansatz, Hamiltonian, and one or more devices

Check out the [quantum chemistry quickstart](https://pennylane.readthedocs.io/en/stable/introduction/chemistry.html), as well the quantum chemistry and VQE tutorials.

* Added a circuit drawing feature that provides a text-based representation of a QNode instance. It can be invoked via `qnode.draw()`. The user can specify to display variable names instead of variable values and choose either an ASCII or Unicode charset. [(446)](https://github.com/XanaduAI/pennylane/pull/446)

* Added `QAOAEmbedding` and its parameter initialization as a new trainable template.
[(442)](https://github.com/XanaduAI/pennylane/pull/442)

* Added the `qml.probs()` measurement function, allowing QNodes to differentiate variational circuit probabilities on simulators and hardware. QNodes that return probabilities fully support autodifferentiation. [(432)](https://github.com/XanaduAI/pennylane/pull/432)

* Added the convenience load functions `qml.from_pyquil`, `qml.from_quil` and `qml.from_quil_file` that convert pyQuil objects and Quil code to PennyLane templates. This feature requires version 0.8 or above of the PennyLane-Forest plugin. [(459)](https://github.com/XanaduAI/pennylane/pull/459)

* Added a `qml.inv` method that inverts templates and sequences of Operations. Added a `qml.template` decorator that makes templates return the queued Operations. [(462)](https://github.com/XanaduAI/pennylane/pull/462)

* Added the `QNodeCollection` container class, that allows independent QNodes to be stored and evaluated simultaneously. Experimental support for asynchronous evaluation of contained QNodes is provided with the `parallel=True` keyword argument. [(466)](https://github.com/XanaduAI/pennylane/pull/466)

* Added a high level `qml.map` function, that maps a quantum circuit template over a list of observables or devices, returning a `QNodeCollection`. [(466)](https://github.com/XanaduAI/pennylane/pull/466)

* Added high level `qml.sum`, `qml.dot`, `qml.apply` functions that act on QNode collections. `qml.sum` and `qml.dot` take the sum of a QNode collection, and a dot product of tensors/arrays/QNode collections, respectively.[(466)](https://github.com/XanaduAI/pennylane/pull/466)

Breaking changes

* Deprecated the old-style `QNode` such that only the new-style `QNode` and its syntax can be used, moved all related files from the `pennylane/beta` folder to `pennylane`. [(440)](https://github.com/XanaduAI/pennylane/pull/440)

Improvements

* Added the `Tensor.prune()` method and the `Tensor.non_identity_obs` property for extracting non-identity instances from the observables making up a `Tensor` instance. [(498)](https://github.com/XanaduAI/pennylane/pull/498)

* Renamed the `expt.tensornet` and `expt.tensornet.tf` devices to `default.tensor` and `default.tensor.tf`. [(495)](https://github.com/XanaduAI/pennylane/pull/495)

* Added a serialization method to the `CircuitGraph` class that is used to create a unique hash for each quantum circuit graph. [(470)](https://github.com/XanaduAI/pennylane/pull/470)

* Added the ``Observable.eigvals`` method to return the eigenvalues of observables. [(449)](https://github.com/XanaduAI/pennylane/pull/449)

* Added the `Observable.diagonalizing_gates` method to return the gates that diagonalize an observable in the computational basis. [(454)](https://github.com/XanaduAI/pennylane/pull/454)

* Added the `Operator.matrix` method to return the matrix representation of an operator in the computational basis. [(454)](https://github.com/XanaduAI/pennylane/pull/454)

* Added a `QubitDevice` class which implements common functionalities of plugin devices such that plugin devices can rely on these implementations. The new `QubitDevice` includes a new `execute` method, which allows for more convenient plugin design. As a result, the way samples are generated on qubit based devices has been unified. [(461)](https://github.com/XanaduAI/pennylane/pull/461) [(#452)](https://github.com/XanaduAI/pennylane/pull/452) [(#473)](https://github.com/XanaduAI/pennylane/pull/473)

* Improved documentation of `AmplitudeEmbedding` and `BasisEmbedding` templates. [(441)](https://github.com/XanaduAI/pennylane/pull/441) [(#439)](https://github.com/XanaduAI/pennylane/pull/439)

* Codeblocks in the documentation now have a 'copy' button for easily copying examples. [(437)](https://github.com/XanaduAI/pennylane/pull/437)

Documentation

* Update the developers plugin guide to use QubitDevice. [(483)](https://github.com/XanaduAI/pennylane/pull/483)

Bug fixes

* Fixed a bug in `CVQNode._pd_analytic`, where non-descendant observables were not Heisenberg-transformed before evaluating the partial derivatives when using the order-2 parameter-shift method, resulting in an erroneous Jacobian for some circuits. [(433)](https://github.com/XanaduAI/pennylane/pull/433)

Contributors

This release contains contributions from (in alphabetical order):

Juan Miguel Arrazola, Ville Bergholm, Alain Delgado Gran, Olivia Di Matteo, Theodor Isacsson, Josh Izaac, Soran Jahangiri, Nathan Killoran, Johannes Jakob Meyer, Zeyue Niu, Maria Schuld, Antal Száva.

New features since last release

* Custom padding constant in `AmplitudeEmbedding` is supported (see 'Breaking changes'.) [419](https://github.com/XanaduAI/pennylane/pull/419)

* `StronglyEntanglingLayer` and `RandomLayer` now work with a single wire. [409](https://github.com/XanaduAI/pennylane/pull/409) [#413](https://github.com/XanaduAI/pennylane/pull/413)

* Added support for applying the inverse of an `Operation` within a circuit. [377](https://github.com/XanaduAI/pennylane/pull/377)

* Added an `OperationRecorder()` context manager, that allows templates and quantum functions to be executed while recording events. The recorder can be used with and without QNodes as a debugging utility. [388](https://github.com/XanaduAI/pennylane/pull/388)

* Operations can now specify a decomposition that is used when the desired operation is not supported on the target device. [396](https://github.com/XanaduAI/pennylane/pull/396)

* The ability to load circuits from external frameworks as templates has been added via the new `qml.load()` function. This feature requires plugin support --- this initial release provides support for Qiskit circuits and QASM files when `pennylane-qiskit` is installed, via the functions `qml.from_qiskit` and `qml.from_qasm`. [418](https://github.com/XanaduAI/pennylane/pull/418)

* An experimental tensor network device has been added [416](https://github.com/XanaduAI/pennylane/pull/416) [#395](https://github.com/XanaduAI/pennylane/pull/395) [#394](https://github.com/XanaduAI/pennylane/pull/394) [#380](https://github.com/XanaduAI/pennylane/pull/380)

* An experimental tensor network device which uses TensorFlow for backpropagation has been added [427](https://github.com/XanaduAI/pennylane/pull/427)

* Custom padding constant in `AmplitudeEmbedding` is supported (see 'Breaking changes'.) [419](https://github.com/XanaduAI/pennylane/pull/419)

Breaking changes

* The ``pad`` parameter in `AmplitudeEmbedding()`` is now either ``None`` (no automatic padding), or a number that is used as the padding constant. [419](https://github.com/XanaduAI/pennylane/pull/419)

* Initialization functions now return a single array of weights per function. Utilities for multi-weight templates `Interferometer()` and `CVNeuralNetLayers()` are provided. [412](https://github.com/XanaduAI/pennylane/pull/412)

* The single layer templates `RandomLayer()`, `CVNeuralNetLayer()` and `StronglyEntanglingLayer()` have been turned into private functions `_random_layer()`, `_cv_neural_net_layer()` and `_strongly_entangling_layer()`. Recommended use is now via the corresponding `Layers()` templates. [413](https://github.com/XanaduAI/pennylane/pull/413)

Improvements

* Added extensive input checks in templates. [419](https://github.com/XanaduAI/pennylane/pull/419)

* Templates integration tests are rewritten - now cover keyword/positional argument passing, interfaces and combinations of templates. [409](https://github.com/XanaduAI/pennylane/pull/409) [#419](https://github.com/XanaduAI/pennylane/pull/419)

* State vector preparation operations in the `default.qubit` plugin can now be applied to subsets of wires, and are restricted to being the first operation in a circuit. [346](https://github.com/XanaduAI/pennylane/pull/346)

* The `QNode` class is split into a hierarchy of simpler classes. [354](https://github.com/XanaduAI/pennylane/pull/354) [#398](https://github.com/XanaduAI/pennylane/pull/398) [#415](https://github.com/XanaduAI/pennylane/pull/415) [#417](https://github.com/XanaduAI/pennylane/pull/417) [#425](https://github.com/XanaduAI/pennylane/pull/425)

* Added the gates U1, U2 and U3 parametrizing arbitrary unitaries on 1, 2 and 3 qubits and the Toffoli gate to the set of qubit operations. [396](https://github.com/XanaduAI/pennylane/pull/396)

* Changes have been made to accomodate the movement of the main function in `pytest._internal` to `pytest._internal.main` in pip 19.3. [404](https://github.com/XanaduAI/pennylane/pull/404)

* Added the templates `BasisStatePreparation` and `MottonenStatePreparation` that use gates to prepare a basis state and an arbitrary state respectively. [336](https://github.com/XanaduAI/pennylane/pull/336)

* Added decompositions for `BasisState` and `QubitStateVector` based on state preparation templates.
[414](https://github.com/XanaduAI/pennylane/pull/414)

* Replaces the pseudo-inverse in the quantum natural gradient optimizer (which can be numerically unstable) with `np.linalg.solve`. [428](https://github.com/XanaduAI/pennylane/pull/428)

Contributors

This release contains contributions from (in alphabetical order):

Ville Bergholm, Josh Izaac, Nathan Killoran, Angus Lowe, Johannes Jakob Meyer, Oluwatobi Ogunbayo, Maria Schuld, Antal Száva.

New features since last release

* Added a `print_applied` method to QNodes, allowing the operation and observable queue to be printed as last constructed. [378](https://github.com/XanaduAI/pennylane/pull/378)

Improvements

* A new `Operator` base class is introduced, which is inherited by both the `Observable` class and the `Operation` class. [355](https://github.com/XanaduAI/pennylane/pull/355)

* Removed deprecated `abstractproperty` decorators in `_device.py`. [374](https://github.com/XanaduAI/pennylane/pull/374)

* Comprehensive gradient tests have been added for the interfaces. [381](https://github.com/XanaduAI/pennylane/pull/381)

Documentation

* The new restructured documentation has been polished and updated. [387](https://github.com/XanaduAI/pennylane/pull/387) [#375](https://github.com/XanaduAI/pennylane/pull/375) [#372](https://github.com/XanaduAI/pennylane/pull/372) [#370](https://github.com/XanaduAI/pennylane/pull/370) [#369](https://github.com/XanaduAI/pennylane/pull/369) [#367](https://github.com/XanaduAI/pennylane/pull/367) [#364](https://github.com/XanaduAI/pennylane/pull/364)

* Updated the development guides. [382](https://github.com/XanaduAI/pennylane/pull/382) [#379](https://github.com/XanaduAI/pennylane/pull/379)

* Added all modules, classes, and functions to the API section in the documentation. [373](https://github.com/XanaduAI/pennylane/pull/373)

Bug fixes

* Replaces the existing `np.linalg.norm` normalization with hand-coded normalization, allowing AmplitudeEmbedding` to be used with differentiable parameters. AmplitudeEmbedding tests have been added and improved. [376](https://github.com/XanaduAI/pennylane/pull/376)

Contributors

This release contains contributions from (in alphabetical order):

Josh Izaac, Nathan Killoran, Maria Schuld, Antal Száva

New features since last release

* The devices `default.qubit` and `default.gaussian` have a new initialization parameter `analytic` that indicates if expectation values and variances should be calculated analytically and not be estimated from data. [317](https://github.com/XanaduAI/pennylane/pull/317)

* Added C-SWAP gate to the set of qubit operations [330](https://github.com/XanaduAI/pennylane/pull/330)

* The TensorFlow interface has been renamed from `"tfe"` to `"tf"`, and now supports TensorFlow 2.0. [337](https://github.com/XanaduAI/pennylane/pull/337)

* Added the S and T gates to the set of qubit operations. [343](https://github.com/XanaduAI/pennylane/pull/343)

* Tensor observables are now supported within the `expval`, `var`, and `sample` functions, by using the `` operator. [267](https://github.com/XanaduAI/pennylane/pull/267)

Breaking changes

* The argument `n` specifying the number of samples in the method `Device.sample` was removed. Instead, the method will always return `Device.shots` many samples. [317](https://github.com/XanaduAI/pennylane/pull/317)

Improvements

* The number of shots / random samples used to estimate expectation values and variances, `Device.shots`, can now be changed after device creation. [317](https://github.com/XanaduAI/pennylane/pull/317)

* Unified import shortcuts to be under qml in qnode.py and test_operation.py [329](https://github.com/XanaduAI/pennylane/pull/329)

* The quantum natural gradient now uses `scipy.linalg.pinvh` which is more efficient for symmetric matrices than the previously used `scipy.linalg.pinv`. [331](https://github.com/XanaduAI/pennylane/pull/331)

* The deprecated `qml.expval.Observable` syntax has been removed. [267](https://github.com/XanaduAI/pennylane/pull/267)

* Remainder of the unittest-style tests were ported to pytest. [310](https://github.com/XanaduAI/pennylane/pull/310)

* The `do_queue` argument for operations now only takes effect within QNodes. Outside of QNodes, operations can now be instantiated without needing to specify `do_queue`. [359](https://github.com/XanaduAI/pennylane/pull/359)

Documentation

* The docs are rewritten and restructured to contain a code introduction section as well as an API section. [314](https://github.com/XanaduAI/pennylane/pull/275)

* Added Ising model example to the tutorials [319] (https://github.com/XanaduAI/pennylane/pull/319)

* Added tutorial for QAOA on MaxCut problem [328](https://github.com/XanaduAI/pennylane/pull/328)

* Added QGAN flow chart figure to its tutorial [333](https://github.com/XanaduAI/pennylane/pull/333)

* Added missing figures for gallery thumbnails of state-preparation and QGAN tutorials [326](https://github.com/XanaduAI/pennylane/pull/326)

* Fixed typos in the state preparation tutorial [321](https://github.com/XanaduAI/pennylane/pull/321)

* Fixed bug in VQE tutorial 3D plots [327](https://github.com/XanaduAI/pennylane/pull/327)

Bug fixes

* Fixed typo in measurement type error message in qnode.py [341](https://github.com/XanaduAI/pennylane/pull/341)

Contributors

This release contains contributions from (in alphabetical order):

Shahnawaz Ahmed, Ville Bergholm, Aroosa Ijaz, Josh Izaac, Nathan Killoran, Angus Lowe, Johannes Jakob Meyer, Maria Schuld, Antal Száva, Roeland Wiersema.