Pennylane

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

<h4>Efficient state preparation methods 🦾</h4>

* State preparation tailored for matrix product states (MPS) is now supported with :class:`qml.MPSPrep <pennylane.MPSPrep>` on the `lightning.tensor` device. [(6431)](https://github.com/PennyLaneAI/pennylane/pull/6431)

Given a list of $n$ tensors that represents an MPS, $[A^{(0)}, ..., A^{(n-1)}]$, :class:`qml.MPSPrep <pennylane.MPSPrep>` lets you directly inject the MPS into a QNode as the initial state of the circuit without any need for pre-processing. The first and last tensors in the list must be rank-2, while all intermediate tensors should be rank-3.

python
import pennylane as qml
import numpy as np

mps = [
np.array([[0.0, 0.107], [0.994, 0.0]]),
np.array(
[
[[0.0, 0.0, 0.0, -0.0], [1.0, 0.0, 0.0, -0.0]],
[[0.0, 1.0, 0.0, -0.0], [0.0, 0.0, 0.0, -0.0]],
]
),
np.array(
[
[[-1.0, 0.0], [0.0, 0.0]],
[[0.0, 0.0], [0.0, 1.0]],
[[0.0, -1.0], [0.0, 0.0]],
[[0.0, 0.0], [1.0, 0.0]],
]
),
np.array([[-1.0, -0.0], [-0.0, -1.0]]),
]

dev = qml.device("lightning.tensor", wires = [0, 1, 2, 3])
qml.qnode(dev)
def circuit():
qml.MPSPrep(mps, wires = [0,1,2])
return qml.state()


pycon
>>> print(circuit())
[ 0. +0.j 0. +0.j 0. +0.j -0.1066+0.j 0. +0.j 0. +0.j
0. +0.j 0. +0.j 0. +0.j 0. +0.j 0. +0.j 0. +0.j
0.9943+0.j 0. +0.j 0. +0.j 0. +0.j]


At this time, :class:`qml.MPSPrep <pennylane.MPSPrep>` is only supported on the `lightning.tensor` device.

* Custom-made state preparation for linear combinations of quantum states is now available with :class:`qml.Superposition <pennylane.Superposition>`. [(6670)](https://github.com/PennyLaneAI/pennylane/pull/6670)

Given a list of $m$ coefficients $c_i$ and basic states $|b_i\rangle$, :class:`qml.Superposition <pennylane.Superposition>` prepares $|\phi\rangle = \sum_i^m c_i |b_i\rangle$. Here is a simple example showing how to use :class:`qml.Superposition <pennylane.Superposition>` to prepare $\tfrac{1}{\sqrt{2}} |00\rangle + \tfrac{1}{\sqrt{2}} |10\rangle$.

python
coeffs = np.array([0.70710678, 0.70710678])
basis = np.array([[0, 0], [1, 0]])

qml.qnode(qml.device('default.qubit'))
def circuit():
qml.Superposition(coeffs, basis, wires=[0, 1], work_wire=[2])
return qml.state()



>>> circuit()
Array([0.7071068 +0.j, 0. +0.j, 0. +0.j, 0. +0.j,
0.70710677+0.j, 0. +0.j, 0. +0.j, 0. +0.j], dtype=complex64)


Note that specification of one `work_wire` is required.

<h4>Enhanced QSVT functionality 🤩</h4>

* New functionality to calculate and convert phase angles for QSP and QSVT has been added with :func:`qml.poly_to_angles <pennylane.poly_to_angles>` and :func:`qml.transform_angles <pennylane.transform_angles>`. [(6483)](https://github.com/PennyLaneAI/pennylane/pull/6483)

The :func:`qml.poly_to_angles <pennylane.poly_to_angles>` function calculates phase angles directly given polynomial coefficients and the routine in which the angles will be used (`"QSVT"`, `"QSP"`, or `"GQSP"`):
pycon
>>> poly = [0, 1.0, 0, -1/2, 0, 1/3]
>>> qsvt_angles = qml.poly_to_angles(poly, "QSVT")
>>> print(qsvt_angles)
[-5.49778714 1.57079633 1.57079633 0.5833829 1.61095884 0.74753829]


The :func:`qml.transform_angles <pennylane.transform_angles>` function can be used to convert angles from one routine to another:

pycon
>>> qsp_angles = np.array([0.2, 0.3, 0.5])
>>> qsvt_angles = qml.transform_angles(qsp_angles, "QSP", "QSVT")
>>> print(qsvt_angles)
[-6.86858347 1.87079633 -0.28539816]


* The :func:`qml.qsvt <pennylane.qsvt>` function has been improved to be more user-friendly, with enhanced capabilities. [(6520)](https://github.com/PennyLaneAI/pennylane/pull/6520) [(#6693)](https://github.com/PennyLaneAI/pennylane/pull/6693)

Block encoding and phase angle computation are now handled automatically, given a matrix to encode, polynomial coefficients, and a block encoding method (`"prepselprep"`, `"qubitization"`, `"embedding"`, or `"fable"`, all implemented with their corresponding operators in PennyLane).
python
P(x) = -x + 0.5 x^3 + 0.5 x^5
poly = np.array([0, -1, 0, 0.5, 0, 0.5])
hamiltonian = qml.dot([0.3, 0.7], [qml.Z(1), qml.X(1) qml.Z(2)])

dev = qml.device("default.qubit")
qml.qnode(dev)
def circuit():
qml.qsvt(hamiltonian, poly, encoding_wires=[0], block_encoding="prepselprep")
return qml.state()

matrix = qml.matrix(circuit, wire_order=[0, 1, 2])()


pycon
>>> print(matrix[:4, :4].real)
[[-0.1625 0. -0.3793 0. ]
[ 0. -0.1625 0. 0.3793]
[-0.3793 0. 0.1625 0. ]
[ 0. 0.3793 0. 0.1625]]

The old functionality can still be accessed with :func:`qml.qsvt_legacy <pennylane.qsvt_legacy>`.

* A new :class:`qml.GQSP <pennylane.GQSP>` template has been added to perform Generalized Quantum Signal Processing (GQSP). [(6565)](https://github.com/PennyLaneAI/pennylane/pull/6565) Similar to QSVT, GQSP is an algorithm that polynomially transforms an input unitary operator, but with fewer restrictions on the chosen polynomial.

You can also use :func:`qml.poly_to_angles <pennylane.poly_to_angles>` to obtain angles for GQSP!

python
P(x) = 0.1 + 0.2j x + 0.3 x^2
poly = [0.1, 0.2j, 0.3]
angles = qml.poly_to_angles(poly, "GQSP")

qml.prod transforms the qfunc into an Operator
def unitary(wires):
qml.RX(0.3, wires)

dev = qml.device("default.qubit")
qml.qnode(dev)
def circuit(angles):
qml.GQSP(unitary(wires = 1), angles, control = 0)
return qml.state()

matrix = qml.matrix(circuit, wire_order=[0, 1])(angles)
pycon
>>> print(np.round(matrix,3)[:2, :2])
[[0.387+0.198j 0.03 -0.089j]
[0.03 -0.089j 0.387+0.198j]]


<h4>Generalized Trotter products 🐖</h4>

* Trotter products that work on exponentiated operators directly instead of full system hamiltonians can now be encoded into circuits with the addition of :class:`qml.TrotterizedQfunc <pennylane.TrotterizedQfunc>` and :func:`qml.trotterize <pennylane.trotterize>`. This allows for custom specification of the first-order expansion of the Suzuki-Trotter product formula and extrapolating it to the $n^{\text{th}}$ order. [(6627)](https://github.com/PennyLaneAI/pennylane/pull/6627)

If the first-order of the Suzuki-Trotter product formula for a given problem is known, :class:`qml.TrotterizedQfunc <pennylane.TrotterizedQfunc>` and :func:`qml.trotterize <pennylane.trotterize>` let you implement the $n^{\text{th}}$-order product formula while only specifying the first-order term as a quantum function.

python
def my_custom_first_order_expansion(time, theta, phi, wires, flip):
qml.RX(time * theta, wires[0])
qml.RY(time * phi, wires[1])
if flip:
qml.CNOT(wires=wires[:2])


:func:`qml.trotterize <pennylane.trotterize>` requires the quantum function representing the first-order product formula, the number of Trotter steps, and the desired order. It returns a function with the same call signature as the first-order product formula quantum function:

python
qml.qnode(qml.device("default.qubit"))
def my_circuit(time, theta, phi, num_trotter_steps):
qml.trotterize(
first_order_expansion,
n=num_trotter_steps,
order=2,
)(time, theta, phi, wires=['a', 'b'], flip=True)
return qml.state()


Alternatively, :class:`qml.TrotterizedQfunc <pennylane.TrotterizedQfunc>` can be used as follows:

python
qml.qnode(qml.device("default.qubit"))
def my_circuit(time, theta, phi, num_trotter_steps):
qml.TrotterizedQfunc(
time,
theta,
phi,
qfunc=my_custom_first_order_expansion,
n=num_trotter_steps,
order=2,
wires=['a', 'b'],
flip=True,
)
return qml.state()


pycon
>>> time = 0.1
>>> theta, phi = (0.12, -3.45)
>>> print(qml.draw(my_circuit, level="device")(time, theta, phi, num_trotter_steps=1))
a: ──RX(0.01)──╭●─╭●──RX(0.01)──┤ State
b: ──RY(-0.17)─╰X─╰X──RY(-0.17)─┤ State


Both methods produce the same results, but offer different interfaces based on the application or overall preference.

<h4>Bosonic operators 🎈</h4>

A new module, :mod:`qml.bose <pennylane.bose>`, has been added to PennyLane that includes support for constructing and manipulating Bosonic operators and converting between Bosonic operators and qubit operators.

* Bosonic operators analogous to `qml.FermiWord` and `qml.FermiSentence` are now available with :class:`qml.BoseWord <pennylane.BoseWord>` and :class:`qml.BoseSentence <pennylane.BoseSentence>`. [(6518)](https://github.com/PennyLaneAI/pennylane/pull/6518)

:class:`qml.BoseWord <pennylane.BoseWord>` and :class:`qml.BoseSentence <pennylane.BoseSentence>` operate similarly to their fermionic counterparts. To create a Bose word, a dictionary is required as input, where the keys are tuples of boson indices and values are `'+/-'` (denoting the bosonic creation/annihilation operators). For example, the $b^{\dagger}_0 b_1$ can be constructed as follows.

pycon
>>> w = qml.BoseWord({(0, 0) : '+', (1, 1) : '-'})
>>> print(w)
b⁺(0) b(1)


Multiple Bose words can then be combined to form a Bose sentence:

pycon
>>> w1 = qml.BoseWord({(0, 0) : '+', (1, 1) : '-'})
>>> w2 = qml.BoseWord({(0, 1) : '+', (1, 2) : '-'})
>>> s = qml.BoseSentence({w1 : 1.2, w2: 3.1})
>>> print(s)
1.2 * b⁺(0) b(1)
+ 3.1 * b⁺(1) b(2)


* Functionality for converting bosonic operators to qubit operators is available with :func:`qml.unary_mapping <pennylane.unary_mapping>`, :func:`qml.binary_mapping <pennylane.binary_mapping>`, and :func:`qml.christiansen_mapping <pennylane.christiansen_mapping>`. [(6623)](https://github.com/PennyLaneAI/pennylane/pull/6623) [(#6576)](https://github.com/PennyLaneAI/pennylane/pull/6576) [(#6564)](https://github.com/PennyLaneAI/pennylane/pull/6564)

All three mappings follow the same syntax, where a :class:`qml.BoseWord <pennylane.BoseWord>` or :class:`qml.BoseSentence <pennylane.BoseSentence>` is required as input.

python
>>> w = qml.BoseWord({(0, 0): "+"})
>>> qml.binary_mapping(w, n_states=4)
0.6830127018922193 * X(0)
+ -0.1830127018922193 * X(0) Z(1)
+ -0.6830127018922193j * Y(0)
+ 0.1830127018922193j * Y(0) Z(1)
+ 0.3535533905932738 * X(0) X(1)
+ -0.3535533905932738j * X(0) Y(1)
+ 0.3535533905932738j * Y(0) X(1)
+ (0.3535533905932738+0j) * Y(0) Y(1)


Additional fine-tuning is available within each function, such as the maximum number of allowed bosonic states and a tolerance for discarding imaginary parts of the coefficients.

<h4>Construct vibrational Hamiltonians 🔨</h4>

* Several new features are available in the :mod:`qml.qchem <pennylane.qchem>` module to help with the construction of vibrational Hamiltonians. This includes:
* The :class:`~.qchem.VibrationalPES` class to store potential energy surface information. [(6652)](https://github.com/PennyLaneAI/pennylane/pull/6652)

python
pes_onemode = np.array([[0.309, 0.115, 0.038, 0.008, 0.000, 0.006, 0.020, 0.041, 0.070]])
pes_twomode = np.zeros((1, 1, 9, 9))
dipole_onemode = np.zeros((1, 9, 3))
gauss_weights = np.array([3.96e-05, 4.94e-03, 8.85e-02,
4.33e-01, 7.20e-01, 4.33e-01,
8.85e-02, 4.94e-03, 3.96e-05])
grid = np.array([-3.19, -2.27, -1.47, -0.72, 0.0, 0.72, 1.47, 2.27, 3.19])
pes_object = qml.qchem.VibrationalPES(
freqs=np.array([0.025]),
grid=grid,
uloc=np.array([[1.0]]),
gauss_weights=gauss_weights,
pes_data=[pes_onemode, pes_twomode],
dipole_data=[dipole_onemode],
localized=False,
dipole_level=1,
)


* The :func:`~.qchem.taylor_hamiltonian` function to build a Taylor Hamiltonian from a :class:`~.VibrationalPES` object. [(6523)](https://github.com/PennyLaneAI/pennylane/pull/6523)

pycon
>>> qml.qchem.taylor_hamiltonian(pes_object, 4, 2)
(
0.016867926879358452 * I(0)
+ -0.007078617919572303 * Z(0)
+ 0.0008679410939323631 * X(0)
)


* The :func:`~.qchem.taylor_bosonic` function to build a Taylor Hamiltonian in terms of Bosonic operators. [(6523)](https://github.com/PennyLaneAI/pennylane/pull/6523)

pycon
>>> coeffs_arr = qml.qchem.taylor_coeffs(pes_object)
>>> bose_op = qml.qchem.taylor_bosonic(coeffs_arr, pes_object.freqs, is_local=pes_object.localized, uloc=pes_object.uloc)
>>> type(bose_op)
pennylane.bose.bosonic.BoseSentence


Additional functionality is also available to optimize molecular geometries and convert between representations:
* Convert Christiansen Hamiltonian integrals in the harmonic oscillator basis to integrals in the vibrational self-consistent field (VSCF) basis with the :func:`~.qchem.vscf_integrals` function. [(6688)](https://github.com/PennyLaneAI/pennylane/pull/6688)

* Find the lowest energy configuration of molecules with :func:`~.qchem.optimize_geometry`. [(6453)](https://github.com/PennyLaneAI/pennylane/pull/6453) [(#6666)](https://github.com/PennyLaneAI/pennylane/pull/6666)

* Separate normal mode frequencies and localize them with :func:`~.qchem.localize_normal_modes`. [(6453)](https://github.com/PennyLaneAI/pennylane/pull/6453)

<h3>Labs: a place for unified and rapid prototyping of research software 🧑‍🔬</h3>

The new :mod:`qml.labs <pennylane.labs>` module will house experimental research software 🔬. Features here may be useful for state-of-the-art research, beta testing, or getting a sneak peek into *potential* new features before they are added to PennyLane.

The experimental nature of this module means features may not integrate well with other PennyLane staples like differentiability, JAX, or JIT compatibility. There may also be unexpected sharp bits 🔪 and errors ❌.

.. warning:: This module is **experimental**! Breaking changes and removals will happen without warning. Please use these features carefully and let us know your thoughts. Your feedback will inform how these features become a part of mainline PennyLane.

<h4>Resource estimation</h4>

* Resource estimation functionality in Labs is focused on being light-weight and flexible. The Labs :mod:`qml.labs.resource_estimation <pennylane.labs.resource_estimation>` module involves modifications to core PennyLane that reduce the memory requirements and computational time of resource estimation. These include new or modified base classes and one new function:
* :class:`~.labs.resource_estimation.Resources` - This class is simplified in `labs`, removing the arguments: `gate_sizes`, `depth`, and `shots`. [(6428)](https://github.com/PennyLaneAI/pennylane/pull/6428)
* :class:`~.labs.resource_estimation.ResourceOperator` - Replaces :class:`~.resource.ResourceOperation`, expanded to include decompositions. [(6428)](https://github.com/PennyLaneAI/pennylane/pull/6428)
* :class:`~.labs.resource_estimation.CompressedResourceOp` - A new class with the minimum information to estimate resources: the operator type and the parameters needed to decompose it. [(6428)](https://github.com/PennyLaneAI/pennylane/pull/6428)
* :class:`~.labs.resource_estimation.ResourceOperator` - versions of many existing PennyLane operations, like Pauli operators, :class:`~.labs.resource_estimation.ResourceHadamard`, and :class:`~.labs.resource_estimation.ResourceCNOT`. [(6447)](https://github.com/PennyLaneAI/pennylane/pull/6447) [(#6579)](https://github.com/PennyLaneAI/pennylane/pull/6579) [(#6538)](https://github.com/PennyLaneAI/pennylane/pull/6538) [(#6592)](https://github.com/PennyLaneAI/pennylane/pull/6592)
* :func:`~.labs.resource_estimation.get_resources()` - The new entry point to efficiently obtain the resources of quantum circuits. [(6500)](https://github.com/PennyLaneAI/pennylane/pull/6500)

Using new Resource versions of existing operations and :func:`~.labs.resource_estimation.get_resources`, we can estimate resources quickly:

python
import pennylane.labs.resource_estimation as re

def my_circuit():
for w in range(2):
re.ResourceHadamard(w)
re.ResourceCNOT([0, 1])
re.ResourceRX(1.23, 0)
re.ResourceRY(-4.56, 1)
re.ResourceQFT(wires=[0, 1, 2])
return qml.expval(re.ResourceHadamard(2))


pycon
>>> res = re.get_resources(my_circuit)()
>>> print(res)
wires: 3
gates: 202
gate_types:
{'Hadamard': 5, 'CNOT': 10, 'T': 187}


We can also set custom gate sets for decompositions:

`pycon
>>> gate_set={"Hadamard","CNOT","RZ", "RX", "RY", "SWAP"}
>>> res = re.get_resources(my_circuit, gate_set=gate_set)()
>>> print(res)
wires: 3
gates: 24
gate_types:
{'Hadamard': 5, 'CNOT': 7, 'RX': 1, 'RY': 1, 'SWAP': 1, 'RZ': 9}
`

Alternatively, it is possible to manually substitute associated resources:

pycon
>>> new_resources = re.substitute(res, "SWAP", re.Resources(2, 3, {"CNOT":3}))
>>> print(new_resources)
{'Hadamard': 5, 'CNOT': 10, 'RX': 1, 'RY': 1, 'RZ': 9}


<h4>Experimental functionality for handling dynamical Lie algebras (DLAs)</h4>

* Use the :mod:`qml.labs.dla <pennylane.labs.dla>` module to perform the [KAK decomposition](https://pennylane.ai/qml/demos/tutorial_kak_decomposition):
* :func:`~.labs.dla.cartan_decomp`: obtain a **Cartan decomposition** of an input **Lie algebra** via an **involution**. [(6392)](https://github.com/PennyLaneAI/pennylane/pull/6392)
* We provide a variety of **involutions** like :func:`~.labs.dla.concurrence_involution`, :func:`~.labs.dla.even_odd_involution` and canonical Cartan involutions. [(6392)](https://github.com/PennyLaneAI/pennylane/pull/6392) [(#6396)](https://github.com/PennyLaneAI/pennylane/pull/6396)
* :func:`~.labs.dla.cartan_subalgebra`: compute a horizontal **Cartan subalgebra**. [(6403)](https://github.com/PennyLaneAI/pennylane/pull/6403)
* :func:`~.labs.dla.variational_kak_adj` : compute a [variational KAK decomposition](https://pennylane.ai/qml/demos/tutorial_fixed_depth_hamiltonian_simulation_via_cartan_decomposition) of a Hermitian operator using a **Cartan decomposition** and the adjoint representation of a horizontal **Cartan subalgebra**. [(#6446)](https://github.com/PennyLaneAI/pennylane/pull/6446)

To use this functionality we start with a set of Hermitian operators.

pycon
>>> n = 3
>>> gens = [qml.X(i) qml.X(i + 1) for i in range(n - 1)]
>>> gens += [qml.Z(i) for i in range(n)]
>>> H = qml.sum(*gens)


We then generate its Lie algebra by computing the Lie closure.

pycon
>>> g = qml.lie_closure(gens)
>>> g = [op.pauli_rep for op in g]
>>> print(g)
[1 * X(0) X(1), 1 * X(1) X(2), 1.0 * Z(0), ...]


We then choose an involution (e.g. :func:`~.labs.dla.concurrence_involution`) that defines a Cartan decomposition `g = k + m`. `k` is the vertical subalgebra, and `m` its horizontal complement (not a subalgebra).

pycon
>>> from pennylane.labs.dla import concurrence_involution, cartan_decomp
>>> involution = concurrence_involution
>>> k, m = cartan_decomp(g, involution=involution)


The next step is just re-ordering the basis elements in `g` and computing its `structure_constants`.

pycon
>>> g = k + m
>>> adj = qml.structure_constants(g)


We can then compute a (horizontal) Cartan subalgebra `a`, that is, a maximal Abelian subalgebra of `m`.

pycon
>>> from pennylane.labs.dla import cartan_subalgebra
>>> g, k, mtilde, a, adj = cartan_subalgebra(g, k, m, adj)


Having determined both subalgebras `k` and `a`, we can compute the KAK decomposition variationally like in [2104.00728](https://arxiv.org/abs/2104.00728), see our [demo on KAK decomposition in practice](https://pennylane.ai/qml/demos/tutorial_fixed_depth_hamiltonian_simulation_via_cartan_decomposition).

pycon
>>> from pennylane.labs.dla import variational_kak_adj
>>> dims = (len(k), len(mtilde), len(a))
>>> adjvec_a, theta_opt = variational_kak_adj(H, g, dims, adj, opt_kwargs={"n_epochs": 3000})


* We also provide some additional features that are useful for handling dynamical Lie algebras.
* :func:`~.labs.dla.recursive_cartan_decomp`: perform consecutive recursive Cartan decompositions. [(6396)](https://github.com/PennyLaneAI/pennylane/pull/6396)
* :func:`~.labs.dla.lie_closure_dense`: extension of `qml.lie_closure` using dense matrices. [(6371)](https://github.com/PennyLaneAI/pennylane/pull/6371) [(#6695)](https://github.com/PennyLaneAI/pennylane/pull/6695)
* :func:`~.labs.dla.structure_constants_dense`: extension of `qml.structure_constants` using dense matrices. [(6396)](https://github.com/PennyLaneAI/pennylane/pull/6396) [(#6376)](https://github.com/PennyLaneAI/pennylane/pull/6376)

<h4>Vibrational Hamiltonians</h4>

* New functionality in labs helps with the construction of vibrational Hamiltonians.
* Generate potential energy surfaces (PES) with `qml.labs.vibrational.vibrational_pes`. [(6616)](https://github.com/PennyLaneAI/pennylane/pull/6616) [(#6676)](https://github.com/PennyLaneAI/pennylane/pull/6676)

pycon
>>> symbols = ['H', 'F']
>>> geometry = np.array([[0.0, 0.0, 0.0], [0.0, 0.0, 1.0]])
>>> mol = qml.qchem.Molecule(symbols, geometry)
>>> pes = vibrational_pes(mol)

* Use the `qml.labs.vibrational.christiansen_hamiltonian` function and potential energy surfaces to generate Hamiltonians in the Christiansen form. [(6560)](https://github.com/PennyLaneAI/pennylane/pull/6560)

<h3>Improvements 🛠</h3>

<h4>QChem improvements</h4>

* The `qml.qchem.factorize` function now supports new methods for double factorization: Cholesky decomposition (`cholesky=True`) and compressed double factorization (`compressed=True`). [(6573)](https://github.com/PennyLaneAI/pennylane/pull/6573) [(#6611)](https://github.com/PennyLaneAI/pennylane/pull/6611)

* A new function for performing the [block-invariant symmetry shift](https://arxiv.org/pdf/2304.13772) on electronic integrals has been added with `qml.qchem.symmetry_shift`. [(#6574)](https://github.com/PennyLaneAI/pennylane/pull/6574)

* The differentiable Hartree-Fock workflow is now compatible with JAX. [(6096)](https://github.com/PennyLaneAI/pennylane/pull/6096) [(#6707)](https://github.com/PennyLaneAI/pennylane/pull/6707)

<h4>Transform for combining GlobalPhase instances</h4>

* A new transform called `qml.transforms.combine_global_phases` has been added. It combines all `qml.GlobalPhase` gates in a circuit into a single one applied at the end. This can be useful for circuits that include a lot of `qml.GlobalPhase` gates that are introduced directly during circuit creation, decompositions that include `qml.GlobalPhase` gates, etc. [(6686)](https://github.com/PennyLaneAI/pennylane/pull/6686)

<h4>Better drawing functionality</h4>

* `qml.draw_mpl` now has a `wire_options` keyword argument, which allows for global- and per-wire customization with options like `color`, `linestyle`, and `linewidth`. [(6486)](https://github.com/PennyLaneAI/pennylane/pull/6486)

Here is an example that would make all wires cyan and bold except for wires 2 and 6, which are dashed and a different colour.

python
qml.qnode(qml.device("default.qubit"))
def circuit(x):
for w in range(5):
qml.Hadamard(w)
return qml.expval(qml.PauliZ(0) qml.PauliY(1))

wire_options = {"color": "cyan",
"linewidth": 5,
2: {"linestyle": "--", "color": "red"},
6: {"linestyle": "--", "color": "orange"}
}
print(qml.draw_mpl(circuit, wire_options=wire_options)(0.52))


<h4>New device capabilities 💾</h4>

* Two new methods, `setup_execution_config` and `preprocess_transforms`, have been added to the `Device` class. Device developers are encouraged to override these two methods separately instead of the `preprocess` method. For now, to avoid ambiguity, a device is allowed to override either these two methods or `preprocess`, but not both. In the long term, we will slowly phase out the use of `preprocess` in favour of these two methods for better separation of concerns. [(6617)](https://github.com/PennyLaneAI/pennylane/pull/6617)

* Developers of plugin devices now have the option of providing a TOML-formatted configuration file to declare the capabilities of the device. See [Device Capabilities](https://docs.pennylane.ai/en/latest/development/plugins.html#device-capabilities) for details.

* An internal module called `qml.devices.capabilities` has been added that defines a new `DeviceCapabilites` data class, as well as functions that load and parse the TOML-formatted configuration files. [(6407)](https://github.com/PennyLaneAI/pennylane/pull/6407)

pycon
>>> from pennylane.devices.capabilities import DeviceCapabilities
>>> capabilities = DeviceCapabilities.from_toml_file("my_device.toml")
>>> isinstance(capabilities, DeviceCapabilities)
True


* Devices that extend `qml.devices.Device` now have an optional class attribute called `capabilities`, which is an instance of the `DeviceCapabilities` data class constructed from the configuration file if it exists. Otherwise, it is set to `None`. [(6433)](https://github.com/PennyLaneAI/pennylane/pull/6433)

python
from pennylane.devices import Device

class MyDevice(Device):
config_filepath = "path/to/config.toml"
...


pycon
>>> isinstance(MyDevice.capabilities, DeviceCapabilities)
True


* Default implementations of `Device.setup_execution_config` and `Device.preprocess_transforms` have been added to the device API for devices that provide a TOML configuration file and, thus, have a `capabilities` property. [(6632)](https://github.com/PennyLaneAI/pennylane/pull/6632) [(#6653)](https://github.com/PennyLaneAI/pennylane/pull/6653)

<h4>Capturing and representing hybrid programs</h4>

* Support has been added for `if`/`else` statements and `for` and `while` loops in circuits executed with `qml.capture.enabled`, via Autograph. Autograph conversion is now used by default in `make_plxpr`, but can be skipped with `autograph=False`. [(6406)](https://github.com/PennyLaneAI/pennylane/pull/6406) [(#6413)](https://github.com/PennyLaneAI/pennylane/pull/6413) [(#6426)](https://github.com/PennyLaneAI/pennylane/pull/6426) [(#6645)](https://github.com/PennyLaneAI/pennylane/pull/6645) [(#6685)](https://github.com/PennyLaneAI/pennylane/pull/6685)

* `qml.transform` now accepts a `plxpr_transform` argument. This argument must be a function that can transform plxpr. Note that executing a transformed function will currently raise a `NotImplementedError`. To see more details, check out the :func:`documentation of qml.transform <pennylane.transform>`. [(6633)](https://github.com/PennyLaneAI/pennylane/pull/6633) [(#6722)](https://github.com/PennyLaneAI/pennylane/pull/6722)

* Users can now apply transforms with program capture enabled. Transformed functions cannot be executed by default. To apply the transforms (and to be able to execute the function), it must be decorated with the new `qml.capture.expand_plxpr_transforms` function, which accepts a callable as input and returns a new function for which all present transforms have been applied. [(6722)](https://github.com/PennyLaneAI/pennylane/pull/6722)

python
from functools import partial

qml.capture.enable()
wire_map = {0: 3, 1: 6, 2: 9}

partial(qml.map_wires, wire_map=wire_map)
def circuit(x, y):
qml.RX(x, 0)
qml.CNOT([0, 1])
qml.CRY(y, [1, 2])
return qml.expval(qml.Z(2))


pycon
>>> qml.capture.make_plxpr(circuit)(1.2, 3.4)
{ lambda ; a:f32[] b:f32[]. let
c:AbstractMeasurement(n_wires=None) = _map_wires_transform_transform[
args_slice=slice(0, 2, None)
consts_slice=slice(2, 2, None)
inner_jaxpr={ lambda ; d:f32[] e:f32[]. let
_:AbstractOperator() = RX[n_wires=1] d 0
_:AbstractOperator() = CNOT[n_wires=2] 0 1
_:AbstractOperator() = CRY[n_wires=2] e 1 2
f:AbstractOperator() = PauliZ[n_wires=1] 2
g:AbstractMeasurement(n_wires=None) = expval_obs f
in (g,) }
targs_slice=slice(2, None, None)
tkwargs={'wire_map': {0: 3, 1: 6, 2: 9}, 'queue': False}
] a b
in (c,) }
>>> transformed_circuit = qml.capture.expand_plxpr_transforms(circuit)
>>> jax.make_jaxpr(transformed_circuit)(1.2, 3.4)
{ lambda ; a:f32[] b:f32[]. let
_:AbstractOperator() = RX[n_wires=1] a 3
_:AbstractOperator() = CNOT[n_wires=2] 3 6
_:AbstractOperator() = CRY[n_wires=2] b 6 9
c:AbstractOperator() = PauliZ[n_wires=1] 9
d:AbstractMeasurement(n_wires=None) = expval_obs c
in (d,) }


* The `qml.iterative_qpe` function can now be compactly captured into plxpr. [(6680)](https://github.com/PennyLaneAI/pennylane/pull/6680)

* Three new plxpr interpreters have been added that allow for functions and plxpr to be natively transformed with the same API as the corresponding existing transforms in PennyLane when program capture is enabled:

* `qml.capture.transforms.CancelInterpreter`:this class cancels operators appearing consecutively that are adjoints of each other following the same API as `qml.transforms.cancel_inverses`. [(6692)](https://github.com/PennyLaneAI/pennylane/pull/6692)

* `qml.capture.transforms.DecomposeInterpreter`: this class decomposes pennylane operators following the same API as `qml.transforms.decompose`. [(6691)](https://github.com/PennyLaneAI/pennylane/pull/6691)

* `qml.capture.transforms.MapWiresInterpreter`: this class maps wires to new values following the same API as `qml.map_wires`. [(6697)](https://github.com/PennyLaneAI/pennylane/pull/6697)

* A `qml.tape.plxpr_to_tape` function is now available that converts plxpr to a tape. [(6343)](https://github.com/PennyLaneAI/pennylane/pull/6343)

* Execution with capture enabled now follows a new execution pipeline and natively passes the captured plxpr to the device. Since it no longer falls back to the old pipeline, execution only works with a reduced feature set. [(6655)](https://github.com/PennyLaneAI/pennylane/pull/6655) [(#6596)](https://github.com/PennyLaneAI/pennylane/pull/6596)

* PennyLane transforms can now be captured as primitives with experimental program capture enabled. [(6633)](https://github.com/PennyLaneAI/pennylane/pull/6633)

* `jax.vmap` can be captured with `qml.capture.make_plxpr` and is compatible with quantum circuits. [(6349)](https://github.com/PennyLaneAI/pennylane/pull/6349) [(#6422)](https://github.com/PennyLaneAI/pennylane/pull/6422) [(#6668)](https://github.com/PennyLaneAI/pennylane/pull/6668)

* A `qml.capture.PlxprInterpreter` base class has been added for easy transformation and execution of plxpr. [(6141)](https://github.com/PennyLaneAI/pennylane/pull/6141)

* A `DefaultQubitInterpreter` class has been added to provide plxpr execution using python based tools, and the `DefaultQubit.eval_jaxpr` method has been implemented. [(6594)](https://github.com/PennyLaneAI/pennylane/pull/6594) [(#6328)](https://github.com/PennyLaneAI/pennylane/pull/6328)

* An optional method, `eval_jaxpr`, has been added to the device API for native execution of plxpr programs. [(6580)](https://github.com/PennyLaneAI/pennylane/pull/6580)

* `qml.capture.qnode_call` has been made private and moved to the `workflow` module. [(6620)](https://github.com/PennyLaneAI/pennylane/pull/6620/)

<h4>Other Improvements</h4>

* `qml.math.grad` and `qml.math.jacobian` have been added to differentiate a function with inputs of any interface in a JAX-like manner. [(6741)](https://github.com/PennyLaneAI/pennylane/pull/6741)

* `qml.GroverOperator` now has a `work_wires` property. [(6738)](https://github.com/PennyLaneAI/pennylane/pull/6738)

* The `Wires` object's usage across Pennylane source code has been tidied up for internal consistency. [(6689)](https://github.com/PennyLaneAI/pennylane/pull/6689)

* `qml.equal` now supports `qml.PauliWord` and `qml.PauliSentence` instances. [(6703)](https://github.com/PennyLaneAI/pennylane/pull/6703)

* Redundant commutator computations from `qml.lie_closure` have been removed. [(6724)](https://github.com/PennyLaneAI/pennylane/pull/6724)

* A comprehensive error is now raised when using `qml.fourier.qnode_spectrum` with standard Numpy arguments and `interface="auto"`. [(6622)](https://github.com/PennyLaneAI/pennylane/pull/6622)

* Pauli string representations for the gates `{X, Y, Z, S, T, SX, SWAP, ISWAP, ECR, SISWAP}` have been added, and a shape error in the matrix conversion of `qml.PauliSentence`s with `list` or `array` inputs has been fixed. [(6562)](https://github.com/PennyLaneAI/pennylane/pull/6562) [(#6587)](https://github.com/PennyLaneAI/pennylane/pull/6587)

* `qml.QNode` and `qml.execute` now forbid certain keyword arguments from being passed positionally. [(6610)](https://github.com/PennyLaneAI/pennylane/pull/6610)

* The string representations for the `qml.S`, `qml.T`, and `qml.SX` have been shortened. [(6542)](https://github.com/PennyLaneAI/pennylane/pull/6542)

* Internal class functions and dunder methods have been added to allow for multiplying Resources objects in series and in parallel. [(6567)](https://github.com/PennyLaneAI/pennylane/pull/6567)

* The `diagonalize_measurements` transform no longer raises an error for unknown observables. Instead, they are left un-diagonalized, with the expectation that observable validation will catch any un-diagonalized observables that are also unsupported by the device. [(6653)](https://github.com/PennyLaneAI/pennylane/pull/6653)

* A `qml.wires.Wires` object can now be converted to a JAX array, if all wire labels are supported as JAX array elements. [(6699)](https://github.com/PennyLaneAI/pennylane/pull/6699)

* PennyLane is compatible with `quimb 1.10.0`. [(6630)](https://github.com/PennyLaneAI/pennylane/pull/6630) [(#6736)](https://github.com/PennyLaneAI/pennylane/pull/6736)

* A developer focused `run` function has been added to the `qml.workflow` module for a cleaner and standardized approach to executing tapes on an ML interface. [(6657)](https://github.com/PennyLaneAI/pennylane/pull/6657)

* Internal changes have been made to standardize execution interfaces, which resolves ambiguities in how the `interface` value is handled during execution. [(6643)](https://github.com/PennyLaneAI/pennylane/pull/6643)

* All interface handling logic has been moved to `interface_utils.py` in the `qml.math` module. [(6649)](https://github.com/PennyLaneAI/pennylane/pull/6649)

* `qml.execute` can now be used with `diff_method="best"`. Classical cotransform information is now handled lazily by the workflow. Gradient method validation and program setup are now handled inside of `qml.execute`, instead of in `QNode`. [(6716)](https://github.com/PennyLaneAI/pennylane/pull/6716)

* PyTree support for measurements in a circuit has been added. [(6378)](https://github.com/PennyLaneAI/pennylane/pull/6378)

python
qml.qnode(qml.device("default.qubit"))
def circuit():
qml.Hadamard(0)
qml.CNOT([0,1])
return {"Probabilities": qml.probs(), "State": qml.state()}


pycon
>>> circuit()
{'Probabilities': array([0.5, 0. , 0. , 0.5]), 'State': array([0.70710678+0.j, 0. +0.j, 0. +0.j, 0.70710678+0.j])}


* The `_cache_transform` transform has been moved to its own file located in `pennylane/workflow/_cache_transform.py`. [(6624)](https://github.com/PennyLaneAI/pennylane/pull/6624)

* The `qml.BasisRotation` template is now JIT compatible. [(6019)](https://github.com/PennyLaneAI/pennylane/pull/6019) [(#6779)](https://github.com/PennyLaneAI/pennylane/pull/6779)

* The Jaxpr primitives for `for_loop`, `while_loop` and `cond` now store slices instead of numbers of arguments. This helps with keeping track of what order the arguments come in. [(6521)](https://github.com/PennyLaneAI/pennylane/pull/6521)

* The `ExecutionConfig.gradient_method` function has been expanded to store `TransformDispatcher` type. [(6455)](https://github.com/PennyLaneAI/pennylane/pull/6455)

* The string representation of `Resources` instances has been improved to match the attribute names. [(6581)](https://github.com/PennyLaneAI/pennylane/pull/6581)

* The documentation for the `dynamic_one_shot` transform has been improved, and a warning is raised when a user-applied `dynamic_one_shot` transform is ignored in favour of the existing transform in a device's preprocessing transform program. [(6701)](https://github.com/PennyLaneAI/pennylane/pull/6701)

* A `qml.devices.qubit_mixed` module has been added for mixed-state qubit device support. This module introduces an `apply_operation` helper function that features:
* Two density matrix contraction methods using `einsum` and `tensordot`
* Optimized handling of special cases including: Diagonal operators, Identity operators, CX (controlled-X), Multi-controlled X gates, Grover operators [(6379)](https://github.com/PennyLaneAI/pennylane/pull/6379)

* A function called `create_initial_state` has been added to allow for initializing a circuit with a density matrix using `qml.StatePrep` or `qml.QubitDensityMatrix`. [(6503)](https://github.com/PennyLaneAI/pennylane/pull/6503)

* Several additions have been made to eventually migrate the `"default.mixed"` device to the new device API:
* A `preprocess` method has been added to the `QubitMixed` device class to preprocess the quantum circuit before execution. [(6601)](https://github.com/PennyLaneAI/pennylane/pull/6601)
* A new class called `DefaultMixedNewAPI` has been added to the `qml.devices.qubit_mixed` module, which will replace the legacy `DefaultMixed`. [(6607)](https://github.com/PennyLaneAI/pennylane/pull/6607)
* A new submodule called `devices.qubit_mixed.measure` has been added, featuring a `measure` function for measuring qubits in mixed-state devices. [(6637)](https://github.com/PennyLaneAI/pennylane/pull/6637)
* A new submodule called `devices.qubit_mixed.simulate` has been added, featuring a `simulate` function for simulating mixed states in analytic mode. [(6618)](https://github.com/PennyLaneAI/pennylane/pull/6618)
* A new submodule called `devices.qubit_mixed.sampling` has been added, featuring functions `sample_state`, `measure_with_samples` and `sample_probs` for sampling qubits in mixed-state devices. [(6639)](https://github.com/PennyLaneAI/pennylane/pull/6639)
* The finite-shot branch of `devices.qubit_mixed.simulate` has been added, which allows for accepting stochastic arguments such as `shots`, `rng` and `prng_key`. [(6665)](https://github.com/PennyLaneAI/pennylane/pull/6665)
* Support for `qml.Snapshot` has been added. [(6659)](https://github.com/PennyLaneAI/pennylane/pull/6659)

* Reporting of test warnings as failures has been added. [(6217)](https://github.com/PennyLaneAI/pennylane/pull/6217)

* A warning message in the Gradients and training documentation has been added that pertains to `ComplexWarning`s. [(6543)](https://github.com/PennyLaneAI/pennylane/pull/6543)

* A new figure was added to the landing page of the PennyLane website. [(6696)](https://github.com/PennyLaneAI/pennylane/pull/6696)

<h3>Breaking changes 💔</h3>

* The default graph coloring method of `qml.dot`, `qml.sum`, and `qml.pauli.optimize_measurements` for grouping observables was changed from `"rlf"` to `"lf"`. Internally, `qml.pauli.group_observables` has been replaced with `qml.pauli.compute_partition_indices` in several places to improve efficiency. [(6706)](https://github.com/PennyLaneAI/pennylane/pull/6706)

* `qml.fourier.qnode_spectrum` no longer automatically converts pure Numpy parameters to the Autograd framework. As the function uses automatic differentiation for validation, parameters from such a framework have to be used. [(6622)](https://github.com/PennyLaneAI/pennylane/pull/6622)

* `qml.math.jax_argnums_to_tape_trainable` has been moved and made private to avoid an unnecessary QNode dependency in the `qml.math` module. [(6609)](https://github.com/PennyLaneAI/pennylane/pull/6609)

* Gradient transforms are now applied after the user's transform program. This ensures user transforms work as expected on initial structures (e.g., embeddings or entangling layers), guarantees that gradient transforms only process compatible operations, aligns transform order with user expectations, and avoids confusion. [(6590)](https://github.com/PennyLaneAI/pennylane/pull/6590)

* Legacy operator arithmetic has been removed. This includes `qml.ops.Hamiltonian`, `qml.operation.Tensor`, `qml.operation.enable_new_opmath`, `qml.operation.disable_new_opmath`, and `qml.operation.convert_to_legacy_H`. Note that `qml.Hamiltonian` will continue to dispatch to `qml.ops.LinearCombination`. For more information, check out the [updated operator troubleshooting page](https://docs.pennylane.ai/en/stable/news/new_opmath.html). [(#6548)](https://github.com/PennyLaneAI/pennylane/pull/6548) [(#6602)](https://github.com/PennyLaneAI/pennylane/pull/6602) [(#6589)](https://github.com/PennyLaneAI/pennylane/pull/6589)

* The developer-facing `qml.utils` module has been removed. [(6588)](https://github.com/PennyLaneAI/pennylane/pull/6588):

Specifically, the following 4 sets of functions have been either moved or removed:
* `qml.utils._flatten`, `qml.utils.unflatten` has been moved and renamed to `qml.optimize.qng._flatten_np` and `qml.optimize.qng._unflatten_np` respectively.
* `qml.utils._inv_dict` and `qml._get_default_args` have been removed.
* `qml.utils.pauli_eigs` has been moved to `qml.pauli.utils`.
* `qml.utils.expand_vector` has been moved to `qml.math.expand_vector`.

* The `qml.qinfo` module has been removed. Please use the corresponding functions in the `qml.math` and `qml.measurements` modules instead. [(6584)](https://github.com/PennyLaneAI/pennylane/pull/6584)

* Top level access to `Device`, `QubitDevice`, and `QutritDevice` have been removed. Instead, they are available as `qml.devices.LegacyDevice`, `qml.devices.QubitDevice`, and `qml.devices.QutritDevice`, respectively. [(6537)](https://github.com/PennyLaneAI/pennylane/pull/6537)

* The `'ancilla'` argument for `qml.iterative_qpe` has been removed. Instead, use the `'aux_wire'` argument. [(6532)](https://github.com/PennyLaneAI/pennylane/pull/6532)

* The `qml.BasisStatePreparation` template has been removed. Instead, use `qml.BasisState`. [(6528)](https://github.com/PennyLaneAI/pennylane/pull/6528)

* The `qml.workflow.set_shots` helper function has been removed. We no longer interact with the legacy device interface in our code. Instead, shots should be specified on the tape, and the device should use these shots. [(6534)](https://github.com/PennyLaneAI/pennylane/pull/6534)

* `QNode.gradient_fn` has been removed. Please use `QNode.diff_method` instead. `QNode.get_gradient_fn` can also be used to process the differentiation method. [(6535)](https://github.com/PennyLaneAI/pennylane/pull/6535)

* The `qml.QubitStateVector` template has been removed. Instead, use `qml.StatePrep`. [(6525)](https://github.com/PennyLaneAI/pennylane/pull/6525)

* `qml.broadcast` has been removed. Users should use `for` loops instead. [(6527)](https://github.com/PennyLaneAI/pennylane/pull/6527)

* The `max_expansion` argument for `qml.transforms.clifford_t_decomposition` has been removed. [(6571)](https://github.com/PennyLaneAI/pennylane/pull/6571)

* The `expand_depth` argument for `qml.compile` has been removed. [(6531)](https://github.com/PennyLaneAI/pennylane/pull/6531)

* The `qml.shadows.shadow_expval` transform has been removed. Instead, please use the `qml.shadow_expval` measurement process. [(6530)](https://github.com/PennyLaneAI/pennylane/pull/6530) [(#6561)](https://github.com/PennyLaneAI/pennylane/pull/6561)

* The developer-facing ``qml.drawer.MPLDrawer`` argument `n_wires` has been replaced with `wire_map`, which contains more complete information about wire labels and order. This allows the new functionality to specify `wire_options` for specific wires when using string wire labels or non-sequential wire ordering. [(6805)](https://github.com/PennyLaneAI/pennylane/pull/6805)

<h3>Deprecations 👋</h3>

* The `tape` and `qtape` properties of `QNode` have been deprecated. Instead, use the `qml.workflow.construct_tape` function. [(6583)](https://github.com/PennyLaneAI/pennylane/pull/6583) [(#6650)](https://github.com/PennyLaneAI/pennylane/pull/6650)

* The `max_expansion` argument in `qml.devices.preprocess.decompose` is deprecated and will be removed in v0.41. [(6400)](https://github.com/PennyLaneAI/pennylane/pull/6400)

* The `decomp_depth` argument in `qml.transforms.set_decomposition` is deprecated and will be removed in v0.41. [(6400)](https://github.com/PennyLaneAI/pennylane/pull/6400)

* The `output_dim` property of `qml.tape.QuantumScript` has been deprecated. Instead, use method `shape` of `QuantumScript` or `MeasurementProcess` to get the same information. [(6577)](https://github.com/PennyLaneAI/pennylane/pull/6577)

* The `QNode.get_best_method` and `QNode.best_method_str` methods have been deprecated. Instead, use the `qml.workflow.get_best_diff_method` function. [(6418)](https://github.com/PennyLaneAI/pennylane/pull/6418)

* The `qml.execute` `gradient_fn` keyword argument has been renamed to `diff_method` to better align with the termionology used by the QNode. `gradient_fn` will be removed in v0.41. [(6549)](https://github.com/PennyLaneAI/pennylane/pull/6549)

* The old `qml.qsvt` functionality is moved to `qml.qsvt_legacy` and is now deprecated. It will be removed in v0.41. [(6520)](https://github.com/PennyLaneAI/pennylane/pull/6520)

<h3>Documentation 📝</h3>

* The docstrings for `qml.qchem.Molecule` and `qml.qchem.molecular_hamiltonian` have been updated to include a note that says that they are not compatible with `qjit` or `jit`. [(6702)](https://github.com/PennyLaneAI/pennylane/pull/6702)

* The documentation of `TrotterProduct` has been updated to include the impact of the operands in the Hamiltonian on the structure of the created circuit. [(6629)](https://github.com/PennyLaneAI/pennylane/pull/6629)

* The documentation of `QSVT` has been updated to include examples for different block encodings. [(6673)](https://github.com/PennyLaneAI/pennylane/pull/6673)

* The link to `qml.ops.one_qubit_transform` was fixed in the `QubitUnitary` docstring. [(6745)](https://github.com/PennyLaneAI/pennylane/pull/6745)

<h3>Bug fixes 🐛</h3>

* Validation has been added to ensure that the device vjp is only used when the device actually supports it. [(6755)](https://github.com/PennyLaneAI/pennylane/pull/6755/)

* `qml.counts` now returns all outcomes when the `all_outcomes` argument is `True` and mid-circuit measurements are present. [(6732)](https://github.com/PennyLaneAI/pennylane/pull/6732)

* `qml.ControlledQubitUnitary` now has consistent behaviour with program capture enabled. [(6719)](https://github.com/PennyLaneAI/pennylane/pull/6719)

* The `Wires` object now throws a `TypeError` if `wires=None`. [(6713)](https://github.com/PennyLaneAI/pennylane/pull/6713) [(#6720)](https://github.com/PennyLaneAI/pennylane/pull/6720)

* The `qml.Hermitian` class no longer checks that the provided matrix is hermitian. The reason for this removal is to allow for faster execution and avoid incompatibilities with `jax.jit`. [(6642)](https://github.com/PennyLaneAI/pennylane/pull/6642)

* Subclasses of `qml.ops.Controlled` no longer bind the primitives of their base operators when program capture is enabled. [(6672)](https://github.com/PennyLaneAI/pennylane/pull/6672)

* The `qml.HilbertSchmidt` and `qml.LocalHilbertSchmidt` templates now apply the complex conjugate of the unitaries instead of the adjoint, providing the correct result. [(6604)](https://github.com/PennyLaneAI/pennylane/pull/6604)

* QNode return behaviour is now consistent for lists and tuples. [(6568)](https://github.com/PennyLaneAI/pennylane/pull/6568)

* QNodes now accept arguments with types defined in libraries that are not necessarily in the list of supported interfaces, such as the `Graph` class defined in `networkx`. [(6600)](https://github.com/PennyLaneAI/pennylane/pull/6600)

* `qml.math.get_deep_interface` now works properly for Autograd arrays. [(6557)](https://github.com/PennyLaneAI/pennylane/pull/6557)

* Printing instances of `qml.Identity` now returns the correct wires list. [(6506)](https://github.com/PennyLaneAI/pennylane/pull/6506)

<h3>Contributors ✍️</h3>

This release contains contributions from (in alphabetical order):

Guillermo Alonso, Shiwen An, Utkarsh Azad, Astral Cai, Yushao Chen, Isaac De Vlugt, Diksha Dhawan, Lasse Dierich, Lillian Frederiksen, Pietropaolo Frisoni, Simone Gasperini, Diego Guala, Austin Huang, Korbinian Kottmann, Christina Lee, Alan Martin, William Maxwell, Anton Naim Ibrahim, Andrija Paurevic, Justin Pickering, Jay Soni, David Wierichs.

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

<h4>Creating spin Hamiltonians on lattices 💞</h4>

* Functionality for creating custom Hamiltonians on arbitrary lattices has been added. [(6226)](https://github.com/PennyLaneAI/pennylane/pull/6226) [(#6237)](https://github.com/PennyLaneAI/pennylane/pull/6237)

Hamiltonians beyond the available boiler-plate ones in the `qml.spin` module can be created with the addition of three new functions:

* `qml.spin.Lattice`: a new object for instantiating customized lattices via primitive translation vectors and unit cell parameters,
* `qml.spin.generate_lattice`: a utility function for creating standard `Lattice` objects, including `'chain'`, `'square'`, `'rectangle'`, `'triangle'`, `'honeycomb'`, `'kagome'`, `'lieb'`, `'cubic'`, `'bcc'`, `'fcc'`, and `'diamond'`,
* `qml.spin.spin_hamiltonian`: generates a spin `Hamiltonian` object given a `Lattice` object with custom edges/nodes.

An example is shown below for a $3 \times 3$ triangular lattice with open boundary conditions.

python
lattice = qml.spin.Lattice(
n_cells=[3, 3],
vectors=[[1, 0], [np.cos(np.pi/3), np.sin(np.pi/3)]],
positions=[[0, 0]],
boundary_condition=False
)


We can validate this `lattice` against `qml.spin.generate_lattice('triangle', ...)` by checking the `lattice_points` (the $(x, y)$ coordinates of all sites in the lattice):

pycon
>>> lp = lattice.lattice_points
>>> triangular_lattice = qml.spin.generate_lattice('triangle', n_cells=[3, 3])
>>> np.allclose(lp, triangular_lattice.lattice_points)
True


The `edges` of the `Lattice` object are nearest-neighbour by default, where we can add edges by using its `add_edge` method.

Optionally, a `Lattice` object can have interactions and fields endowed to it by specifying values for its `custom_edges` and `custom_nodes` keyword arguments. The Hamiltonian can then be extracted with the `qml.spin.spin_hamiltonian` function. An example is shown below for the transverse-field Ising model Hamiltonian on a $3 \times 3$ triangular lattice. Note that the `custom_edges` and `custom_nodes` keyword arguments only need to be defined for one unit cell repetition.

python
edges = [
(0, 1), (0, 3), (1, 3)
]

lattice = qml.spin.Lattice(
n_cells=[3, 3],
vectors=[[1, 0], [np.cos(np.pi/3), np.sin(np.pi/3)]],
positions=[[0, 0]],
boundary_condition=False,
custom_edges=[[edge, ("ZZ", -1.0)] for edge in edges],
custom_nodes=[[i, ("X", -0.5)] for i in range(3*3)],
)


pycon
>>> tfim_ham = qml.spin.transverse_ising('triangle', [3, 3], coupling=1.0, h=0.5)
>>> tfim_ham == qml.spin.spin_hamiltonian(lattice=lattice)
True


* More industry-standard spin Hamiltonians have been added in the `qml.spin` module. [(6174)](https://github.com/PennyLaneAI/pennylane/pull/6174) [(#6201)](https://github.com/PennyLaneAI/pennylane/pull/6201)

Three new industry-standard spin Hamiltonians are now available with PennyLane v0.39:

* `qml.spin.emery` : the [Emery model](https://journals.aps.org/prl/abstract/10.1103/PhysRevLett.58.2794)
* `qml.spin.haldane` : the [Haldane model](https://journals.aps.org/prl/pdf/10.1103/PhysRevLett.61.2015)
* `qml.spin.kitaev` : the [Kitaev model](https://arxiv.org/abs/cond-mat/0506438)

These additions accompany `qml.spin.heisenberg`, `qml.spin.transverse_ising`, and `qml.spin.fermi_hubbard`, which were introduced in v0.38.

<h4>Calculating Polynomials 🔢</h4>

* Polynomial functions can now be easily encoded into quantum circuits with `qml.OutPoly`. [(6320)](https://github.com/PennyLaneAI/pennylane/pull/6320)

A new template called `qml.OutPoly` is available, which provides the ability to encode a polynomial function in a quantum circuit. Given a polynomial function $f(x_1, x_2, \cdots, x_N)$, `qml.OutPoly` requires:

* `f` : a standard Python function that represents $f(x_1, x_2, \cdots, x_N)$,
* `input_registers` ($\vert x_1 \rangle$, $\vert x_2 \rangle$, ..., $\vert x_N \rangle$) : a list/tuple containing ``Wires`` objects that correspond to the embedded numeric values of $x_1, x_2, \cdots, x_N$,
* `output_wires` : the `Wires` for which the numeric value of $f(x_1, x_2, \cdots, x_N)$ is stored.

Here is an example of using `qml.OutPoly` to calculate $f(x_1, x_2) = 3x_1^2 - x_1x_2$ for $f(1, 2) = 1$.

python
wires = qml.registers({"x1": 1, "x2": 2, "output": 2})

def f(x1, x2):
return 3 * x1 ** 2 - x1 * x2

qml.qnode(qml.device("default.qubit", shots = 1))
def circuit():
load values of x1 and x2
qml.BasisEmbedding(1, wires=wires["x1"])
qml.BasisEmbedding(2, wires=wires["x2"])

apply the polynomial
qml.OutPoly(
f,
input_registers = [wires["x1"], wires["x2"]],
output_wires = wires["output"])

return qml.sample(wires=wires["output"])


pycon
>>> circuit()
array([0, 1])


The result, `[0, 1]`, is the binary representation of $1$. By default, the result is calculated modulo $2^\text{len(output wires)}$ but can be overridden with the `mod` keyword argument.

<h4>Readout Noise 📠</h4>

* Readout errors can now be included in `qml.NoiseModel` and `qml.add_noise` with the new `qml.noise.meas_eq` function. [(6321)](https://github.com/PennyLaneAI/pennylane/pull/6321/)

Measurement/readout errors can be specified in a similar fashion to regular gate noise in PennyLane: a newly added Boolean function called `qml.noise.meas_eq` that accepts a measurement function (e.g., `qml.expval`, `qml.sample`, or any other function that can be returned from a QNode) that, when present in the QNode, inserts a noisy operation via `qml.noise.partial_wires` or a custom noise function. Readout noise in PennyLane also follows the insertion convention, where the specified noise is inserted *before* the measurement.

Here is an example of adding `qml.PhaseFlip` noise to any `qml.expval` measurement:

python
c0 = qml.noise.meas_eq(qml.expval)
n0 = qml.noise.partial_wires(qml.PhaseFlip, 0.2)


To include this in a `qml.NoiseModel`, use its `meas_map` keyword argument:

python
gate-based noise
c1 = qml.noise.wires_in([0, 2])
n1 = qml.noise.partial_wires(qml.RY, -0.42)

noise_model = qml.NoiseModel({c1: n1}, meas_map={c0: n0})


pycon
>>> noise_model
NoiseModel({
WiresIn([0, 2]): RY(phi=-0.42)
},
meas_map = {
MeasEq(expval): PhaseFlip(p=0.2)
})


`qml.noise.meas_eq` can also be combined with other Boolean functions in `qml.noise` via bitwise operators for more versatility.

To add this `noise_model` to a circuit, use the `qml.add_noise` transform as per usual. For example,

python
qml.qnode(qml.device("default.mixed", wires=3))
def circuit():
qml.RX(0.1967, wires=0)
for i in range(3):
qml.Hadamard(i)

return qml.expval(qml.X(0) qml.X(1))


pycon
>>> noisy_circuit = qml.add_noise(circuit, noise_model)
>>> print(qml.draw(noisy_circuit)())
0: ──RX(0.20)──RY(-0.42)────────H──RY(-0.42)──PhaseFlip(0.20)─┤ ╭<XX>
1: ──H─────────PhaseFlip(0.20)────────────────────────────────┤ ╰<XX>
2: ──H─────────RY(-0.42)──────────────────────────────────────┤
>>> print(circuit(), noisy_circuit())
0.9807168489852615 0.35305806563469433


<h4>User-friendly decompositions 📠</h4>

* A new transform called `qml.transforms.decompose` has been added to better facilitate the custom decomposition of operators in PennyLane circuits. [(6334)](https://github.com/PennyLaneAI/pennylane/pull/6334)

Previous to the addition of `qml.transforms.decompose`, decomposing operators in PennyLane had to be done by specifying a `stopping_condition` in `qml.device.preprocess.decompose`. With `qml.transforms.decompose`, the user-interface for specifying decompositions is much simpler and more versatile.

Decomposing gates in a circuit can be done a few ways:

* Specifying a `gate_set` comprising PennyLane `Operator`s to decompose into:

python
from functools import partial

dev = qml.device('default.qubit')
allowed_gates = {qml.Toffoli, qml.RX, qml.RZ}

partial(qml.transforms.decompose, gate_set=allowed_gates)
qml.qnode(dev)
def circuit():
qml.Hadamard(wires=[0])
qml.Toffoli(wires=[0, 1, 2])
return qml.expval(qml.Z(0))


pycon
>>> print(qml.draw(circuit)())
0: ──RZ(1.57)──RX(1.57)──RZ(1.57)─╭●─┤ <Z>
1: ───────────────────────────────├●─┤
2: ───────────────────────────────╰X─┤


* Specifying a `gate_set` that is defined by a rule (Boolean function). For example, one can specify an arbitrary gate set to decompose into, so long as the resulting gates only act on one or two qubits:

python
partial(qml.transforms.decompose, gate_set = lambda op: len(op.wires) <= 2)
qml.qnode(dev)
def circuit():
qml.Toffoli(wires=[0, 1, 2])
return qml.expval(qml.Z(0))


pycon
>>> print(qml.draw(circuit)())
0: ───────────╭●───────────╭●────╭●──T──╭●─┤ <Z>
1: ────╭●─────│─────╭●─────│───T─╰X──T†─╰X─┤
2: ──H─╰X──T†─╰X──T─╰X──T†─╰X──T──H────────┤


* Specifying a value for `max_expansion`. By default, decomposition occurs recursively until the desired gate set is reached, but this can be overridden to control the number of passes.

python
phase = 1.0
target_wires = [0]
unitary = qml.RX(phase, wires=0).matrix()
n_estimation_wires = 1
estimation_wires = range(1, n_estimation_wires + 1)

def qfunc():
qml.QuantumPhaseEstimation(
unitary,
target_wires=target_wires,
estimation_wires=estimation_wires,
)

decompose_once = qml.transforms.decompose(qfunc, max_expansion=1)
decompose_twice = qml.transforms.decompose(qfunc, max_expansion=2)


pycon
>>> print(qml.draw(decompose_once)())
0: ────╭U(M0)¹───────┤
1: ──H─╰●───────QFT†─┤
M0 =
[[0.87758256+0.j 0. -0.47942554j]
[0. -0.47942554j 0.87758256+0.j ]]
>>> print(qml.draw(decompose_twice)())
0: ──RZ(1.57)──RY(0.50)─╭X──RY(-0.50)──RZ(-6.28)─╭X──RZ(4.71)─┤
1: ──H──────────────────╰●───────────────────────╰●──H†───────┤


<h3>Improvements 🛠</h3>

<h4>qjit/jit compatibility and improvements</h4>

[Quantum just-in-time (qjit) compilation](https://pennylane.ai/qml/glossary/what-is-quantum-just-in-time-qjit-compilation/) is the compilation of hybrid quantum-classical programs during execution of a program, rather than before execution. PennyLane provides just-in-time compilation with its `qml.qjit` decorator, powered by the [Catalyst](https://docs.pennylane.ai/projects/catalyst/en/stable/index.html) compiler.

* Several templates are now compatible with qjit:
* `qml.AmplitudeAmplification` [(6306)](https://github.com/PennyLaneAI/pennylane/pull/6306)
* All quantum arithmetic templates [(6307)](https://github.com/PennyLaneAI/pennylane/pull/6307)
* `qml.Qubitization` [(6305)](https://github.com/PennyLaneAI/pennylane/pull/6305)

* The sample-based measurements now support samples that are JAX tracers, allowing compatiblity with qjit workflows. [(6211)](https://github.com/PennyLaneAI/pennylane/pull/6211)

* The `qml.FABLE` template now returns the correct value when jit is enabled. [(6263)](https://github.com/PennyLaneAI/pennylane/pull/6263)

* `qml.metric_tensor` is now jit compatible. [(6468)](https://github.com/PennyLaneAI/pennylane/pull/6468)

* `qml.QutritBasisStatePreparation` is now jit compatible. [(6308)](https://github.com/PennyLaneAI/pennylane/pull/6308)

* All PennyLane templates are now unit tested to ensure jit compatibility. [(6309)](https://github.com/PennyLaneAI/pennylane/pull/6309)

<h4>Various improvements to fermionic operators</h4>

* `qml.fermi.FermiWord` and `qml.fermi.FermiSentence` are now compatible with JAX arrays. [(6324)](https://github.com/PennyLaneAI/pennylane/pull/6324)

Fermionic operators interacting, in some way, with a JAX array will no longer raise an error. For example:

pycon
>>> import jax.numpy as jnp
>>> w = qml.fermi.FermiWord({(0, 0) : '+', (1, 1) : '-'})
>>> jnp.array([3]) * w
FermiSentence({FermiWord({(0, 0): '+', (1, 1): '-'}): Array([3], dtype=int32)})


* The `qml.fermi.FermiWord` class now has a `shift_operator` method to apply anti-commutator relations. [(6196)](https://github.com/PennyLaneAI/pennylane/pull/6196)

pycon
>>> w = qml.fermi.FermiWord({(0, 0): '+', (1, 1): '-'})
>>> w
FermiWord({(0, 0): '+', (1, 1): '-'})
>>> w.shift_operator(0, 1)
FermiSentence({FermiWord({(0, 1): '-', (1, 0): '+'}): -1})


* The `qml.fermi.FermiWord` and `qml.fermi.FermiSentence` classes now an `adjoint` method. [(6166)](https://github.com/PennyLaneAI/pennylane/pull/6166)

pycon
>>> w = qml.fermi.FermiWord({(0, 0): '+', (1, 1): '-'})
>>> w.adjoint()
FermiWord({(0, 1): '+', (1, 0): '-'})


* The `to_mat` methods for `qml.fermi.FermiWord` and `qml.fermi.FermiSentence` now optionally return a sparse matrix with the `format` keyword argument. [(6173)](https://github.com/PennyLaneAI/pennylane/pull/6173)

pycon
>>> w = qml.fermi.FermiWord({(0, 0) : '+', (1, 1) : '-'})
>>> w.to_mat(format="dense")
array([[0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],
[0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],
[0.+0.j, 1.+0.j, 0.+0.j, 0.+0.j],
[0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j]])
>>> w.to_mat(format="csr")
<4x4 sparse matrix of type '<class 'numpy.complex128'>'
with 1 stored elements in Compressed Sparse Row format>


* When printed, `qml.fermi.FermiWord` and `qml.fermi.FermiSentence` now return a unique representation of the object. [(6167)](https://github.com/PennyLaneAI/pennylane/pull/6167)

pycon
>>> w = qml.fermi.FermiWord({(0, 0) : '+', (1, 1) : '-'})
>>> print(w)
a⁺(0) a(1)


* `qml.qchem.excitations` now optionally returns fermionic operators with a new `fermionic` keyword argument (defaults to `False`). [(6171)](https://github.com/PennyLaneAI/pennylane/pull/6171)

pycon
>>> singles, doubles = excitations(electrons, orbitals, fermionic=True)
>>> print(singles)
[FermiWord({(0, 0): '+', (1, 2): '-'}), FermiWord({(0, 1): '+', (1, 3): '-'})]


<h4>A new optimizer</h4>

* A new optimizer called `qml.MomentumQNGOptimizer` has been added. It inherits from the basic `qml.QNGOptimizer` optimizer and requires one additional hyperparameter: the momentum coefficient, $0 \leq \rho < 1$, the default value being $\rho=0.9$. For $\rho=0$, `qml.MomentumQNGOptimizer` reduces down to `qml.QNGOptimizer`. [(6240)](https://github.com/PennyLaneAI/pennylane/pull/6240)

<h4>Other Improvements</h4>

* `default.tensor` can now handle mid-circuit measurements via the deferred measurement principle. [(6408)](https://github.com/PennyLaneAI/pennylane/pull/6408)

* `process_density_matrix` was implemented in 5 `StateMeasurement` subclasses: `ExpVal`, `Var`, `Purity`, `MutualInformation`, and `VnEntropy`. This facilitates future support for mixed-state devices and expanded density matrix operations. Also, a fix was made in the `ProbabilityMP` class to use `qml.math.sqrt` instead of `np.sqrt`. [(6330)](https://github.com/PennyLaneAI/pennylane/pull/6330)

* The decomposition for `qml.Qubitization` has been improved to use `qml.PrepSelPrep`. [(6182)](https://github.com/PennyLaneAI/pennylane/pull/6182)

* A `ReferenceQubit` device (shortname: `"reference.qubit"`) has been introduced for testing purposes and referencing for future plugin development. [(6181)](https://github.com/PennyLaneAI/pennylane/pull/6181)

* `qml.transforms.mitigate_with_zne` now gives a clearer error message when being applied on circuits, not devices, that include channel noise. [(6346)](https://github.com/PennyLaneAI/pennylane/pull/6346)

* A new function called `get_best_diff_method` has been added to `qml.workflow`. [(6399)](https://github.com/PennyLaneAI/pennylane/pull/6399)

* A new method called `construct_tape` has been added to `qml.workflow` for users to construct single tapes from a `QNode`. [(6419)](https://github.com/PennyLaneAI/pennylane/pull/6419)

* An infrastructural improvement was made to PennyLane datasets that allows us to upload datasets more easily. [(6126)](https://github.com/PennyLaneAI/pennylane/pull/6126)

* `qml.Hadamard` now has a more friendly alias: `qml.H`. [(6450)](https://github.com/PennyLaneAI/pennylane/pull/6450)

* A Boolean keyword argument called `show_wire_labels` has been added to `draw` and `draw_mpl`, which hides wire labels when set to `False` (the default is `True`). [(6410)](https://github.com/PennyLaneAI/pennylane/pull/6410)

* A new function called `sample_probs` has been added to the `qml.devices.qubit` and `qml.devices.qutrit_mixed` modules. This function takes probability distributions as input and returns sampled outcomes, simplifying the sampling process by separating it from other operations in the measurement chain and improving modularity. [(6354)](https://github.com/PennyLaneAI/pennylane/pull/6354)

* `qml.labs` has been added to the PennyLane documentation. [(6397)](https://github.com/PennyLaneAI/pennylane/pull/6397) [(#6369)](https://github.com/PennyLaneAI/pennylane/pull/6369)

* A `has_sparse_matrix` property has been added to `Operator` to indicate whether a sparse matrix is defined. [(6278)](https://github.com/PennyLaneAI/pennylane/pull/6278) [(#6310)](https://github.com/PennyLaneAI/pennylane/pull/6310)

* `qml.matrix` now works with empty objects (e.g., empty tapes, QNodes and quantum functions that do not call operations, and single operators with empty decompositions). [(6347)](https://github.com/PennyLaneAI/pennylane/pull/6347)

python
dev = qml.device("default.qubit", wires=1)

qml.qnode(dev)
def node():
return qml.expval(qml.Z(0))


pycon
>>> qml.matrix(node)()
array([[1., 0.],
[0., 1.]])


* PennyLane is now compatible with NumPy 2.0. [(6061)](https://github.com/PennyLaneAI/pennylane/pull/6061) [(#6258)](https://github.com/PennyLaneAI/pennylane/pull/6258) [(#6342)](https://github.com/PennyLaneAI/pennylane/pull/6342)

* PennyLane is now compatible with Jax 0.4.28. [(6255)](https://github.com/PennyLaneAI/pennylane/pull/6255)

* The `diagonalize_measurements` transform now uses a more efficient method of diagonalization when possible, based on the `pauli_rep` of the relevant observables. [(6113)](https://github.com/PennyLaneAI/pennylane/pull/6113/)

* The `QuantumScript.copy` method now takes `operations`, `measurements`, `shots` and `trainable_params` as keyword arguments. If any of these are passed when copying a tape, the specified attributes will replace the copied attributes on the new tape. [(6285)](https://github.com/PennyLaneAI/pennylane/pull/6285) [(#6363)](https://github.com/PennyLaneAI/pennylane/pull/6363)

* The `Hermitian` operator now has a `compute_sparse_matrix` implementation. [(6225)](https://github.com/PennyLaneAI/pennylane/pull/6225)

* When an observable is repeated on a tape, `tape.diagonalizing_gates` no longer returns the diagonalizing gates for each instance of the observable. Instead, the diagonalizing gates of each observable on the tape are included just once. [(6288)](https://github.com/PennyLaneAI/pennylane/pull/6288)

* The number of diagonalizing gates returned in `qml.specs` now follows the `level` keyword argument regarding whether the diagonalizing gates are modified by device, instead of always counting unprocessed diagonalizing gates. [(6290)](https://github.com/PennyLaneAI/pennylane/pull/6290)

* A more sensible error message is raised from a `RecursionError` encountered when accessing properties and methods of a nested `CompositeOp` or `SProd`. [(6375)](https://github.com/PennyLaneAI/pennylane/pull/6375)

By default, `qml.sum` and `qml.prod` set `lazy=True`, which keeps its operands nested. Given the recursive nature of such structures, if there are too many levels of nesting, a `RecursionError` would occur when accessing many of the properties and methods.

* The performance of the decomposition of `qml.QFT` has been improved. [(6434)](https://github.com/PennyLaneAI/pennylane/pull/6434)

<h4>Capturing and representing hybrid programs</h4>

* `qml.wires.Wires` now accepts JAX arrays as input. In many workflows with JAX, PennyLane may attempt to assign a JAX array to a `Wires` object, which will cause an error since JAX arrays are not hashable. Now, JAX arrays are valid `Wires` types. Furthermore, a `FutureWarning` is no longer raised in `JAX 0.4.30+` when providing JAX tracers as input to `qml.wires.Wires`. [(6312)](https://github.com/PennyLaneAI/pennylane/pull/6312)

* A new function called `qml.capture.make_plxpr` has been added to take a function and create a `Callable` that, when called, will return a PLxPR representation of the input function. [(6326)](https://github.com/PennyLaneAI/pennylane/pull/6326)`

* Differentiation of hybrid programs via `qml.grad` and `qml.jacobian` can now be captured with PLxPR. When evaluating a captured `qml.grad` (`qml.jacobian`) instruction, it will dispatch to `jax.grad` (`jax.jacobian`), which differs from the Autograd implementation without capture. Pytree inputs and outputs are supported. [(6120)](https://github.com/PennyLaneAI/pennylane/pull/6120) [(#6127)](https://github.com/PennyLaneAI/pennylane/pull/6127) [(#6134)](https://github.com/PennyLaneAI/pennylane/pull/6134)

* Unit testing for capturing nested control flow has been improved. [(6111)](https://github.com/PennyLaneAI/pennylane/pull/6111)

* Some custom primitives for the capture project can now be imported via `from pennylane.capture.primitives import *`. [(6129)](https://github.com/PennyLaneAI/pennylane/pull/6129)

* All higher order primitives now use `jax.core.Jaxpr` as metadata instead of sometimes using `jax.core.ClosedJaxpr` or `jax.core.Jaxpr`. [(6319)](https://github.com/PennyLaneAI/pennylane/pull/6319)

<h3>Breaking changes 💔</h3>

* Red-herring validation in `QNode.construct` has been removed, which fixed a bug with `qml.GlobalPhase`. [(6373)](https://github.com/PennyLaneAI/pennylane/pull/6373)

Removing the `AllWires` validation in `QNode.construct` was addressed as a solution to the following example not being able to run:

python
qml.qnode(qml.device('default.qubit', wires=2))
def circuit(x):
qml.GlobalPhase(x, wires=0)
return qml.state()


pycon
>>> circuit(0.5)
array([0.87758256-0.47942554j, 0. +0.j ,
1. +0.j , 0. +0.j ])


* The `simplify` argument in `qml.Hamiltonian` and `qml.ops.LinearCombination` has been removed. Instead, `qml.simplify()` can be called on the constructed operator. [(6279)](https://github.com/PennyLaneAI/pennylane/pull/6279)

* The functions `qml.qinfo.classical_fisher` and `qml.qinfo.quantum_fisher` have been removed and migrated to the `qml.gradients` module. `qml.gradients.classical_fisher` and `qml.gradients.quantum_fisher` should be used instead. [(5911)](https://github.com/PennyLaneAI/pennylane/pull/5911)

* Python 3.9 is no longer supported. Please update to 3.10 or newer. [(6223)](https://github.com/PennyLaneAI/pennylane/pull/6223)

* `default.qubit.legacy`, `default.qubit.tf`, `default.qubit.torch`, `default.qubit.jax`, and `default.qubit.autograd` have been removed. Please use `default.qubit` for all interfaces. [(6207)](https://github.com/PennyLaneAI/pennylane/pull/6207) [(#6208)](https://github.com/PennyLaneAI/pennylane/pull/6208) [(#6209)](https://github.com/PennyLaneAI/pennylane/pull/6209) [(#6210)](https://github.com/PennyLaneAI/pennylane/pull/6210) [(#6266)](https://github.com/PennyLaneAI/pennylane/pull/6266)

* `expand_fn`, `max_expansion`, `override_shots`, and `device_batch_transform` have been removed from the signature of `qml.execute`. [(6203)](https://github.com/PennyLaneAI/pennylane/pull/6203)

* `max_expansion` and `expansion_strategy` have been removed from the QNode. [(6203)](https://github.com/PennyLaneAI/pennylane/pull/6203)

* `expansion_strategy` has been removed from `qml.draw`, `qml.draw_mpl`, and `qml.specs`. `max_expansion` has been removed from `qml.specs`, as it had no impact on the output. [(6203)](https://github.com/PennyLaneAI/pennylane/pull/6203)

* `qml.transforms.hamiltonian_expand` and `qml.transforms.sum_expand` have been removed. Please use `qml.transforms.split_non_commuting` instead. [(6204)](https://github.com/PennyLaneAI/pennylane/pull/6204)

* The `decomp_depth` keyword argument to `qml.device` has been removed. [(6234)](https://github.com/PennyLaneAI/pennylane/pull/6234)

* `Operator.expand` has been removed. Please use `qml.tape.QuantumScript(op.decomposition())` instead. [(6227)](https://github.com/PennyLaneAI/pennylane/pull/6227)

* The native folding method `qml.transforms.fold_global` for the `qml.transforms.mitigate_with_zne` transform no longer expands the circuit automatically. Instead, the user should apply `qml.transforms.decompose` to decompose a circuit into a target gate set before applying `fold_global` or `mitigate_with_zne`. [(6382)](https://github.com/PennyLaneAI/pennylane/pull/6382)

* The `LightningVJPs` class has been removed, as all lightning devices now follow the new device interface. [(6420)](https://github.com/PennyLaneAI/pennylane/pull/6420)

<h3>Deprecations 👋</h3>

* The `expand_depth` and `max_expansion` arguments for `qml.transforms.compile` and `qml.transforms.decompositions.clifford_t_decomposition` respectively have been deprecated. [(6404)](https://github.com/PennyLaneAI/pennylane/pull/6404)

* Legacy operator arithmetic has been deprecated. This includes `qml.ops.Hamiltonian`, `qml.operation.Tensor`, `qml.operation.enable_new_opmath`, `qml.operation.disable_new_opmath`, and `qml.operation.convert_to_legacy_H`. Note that when new operator arithmetic is enabled, `qml.Hamiltonian` will continue to dispatch to `qml.ops.LinearCombination`; this behaviour is not deprecated. For more information, check out the [updated operator troubleshooting page](https://docs.pennylane.ai/en/stable/news/new_opmath.html). [(#6287)](https://github.com/PennyLaneAI/pennylane/pull/6287) [(#6365)](https://github.com/PennyLaneAI/pennylane/pull/6365)

* `qml.pauli.PauliSentence.hamiltonian` and `qml.pauli.PauliWord.hamiltonian` have been deprecated. Instead, please use `qml.pauli.PauliSentence.operation` and `qml.pauli.PauliWord.operation`, respectively. [(6287)](https://github.com/PennyLaneAI/pennylane/pull/6287)

* `qml.pauli.simplify()` has been deprecated. Instead, please use `qml.simplify(op)` or `op.simplify()`. [(6287)](https://github.com/PennyLaneAI/pennylane/pull/6287)

* The `qml.BasisStatePreparation` template has been deprecated. Instead, use `qml.BasisState`. [(6021)](https://github.com/PennyLaneAI/pennylane/pull/6021)

* The `'ancilla'` argument for `qml.iterative_qpe` has been deprecated. Instead, use the `'aux_wire'` argument. [(6277)](https://github.com/PennyLaneAI/pennylane/pull/6277)

* `qml.shadows.shadow_expval` has been deprecated. Instead, use the `qml.shadow_expval` measurement process. [(6277)](https://github.com/PennyLaneAI/pennylane/pull/6277)

* `qml.broadcast` has been deprecated. Please use Python `for` loops instead. [(6277)](https://github.com/PennyLaneAI/pennylane/pull/6277)

* The `qml.QubitStateVector` template has been deprecated. Instead, use `qml.StatePrep`. [(6172)](https://github.com/PennyLaneAI/pennylane/pull/6172)

* The `qml.qinfo` module has been deprecated. Please see the respective functions in the `qml.math` and `qml.measurements` modules instead. [(5911)](https://github.com/PennyLaneAI/pennylane/pull/5911)

* `Device`, `QubitDevice`, and `QutritDevice` will no longer be accessible via top-level import in v0.40. They will still be accessible as `qml.devices.LegacyDevice`, `qml.devices.QubitDevice`, and `qml.devices.QutritDevice` respectively. [(6238)](https://github.com/PennyLaneAI/pennylane/pull/6238/)

* `QNode.gradient_fn` has been deprecated. Please use `QNode.diff_method` and `QNode.get_gradient_fn` instead. [(6244)](https://github.com/PennyLaneAI/pennylane/pull/6244)

<h3>Documentation 📝</h3>

* Updated `qml.spin` documentation. [(6387)](https://github.com/PennyLaneAI/pennylane/pull/6387)

* Updated links to PennyLane.ai in the documentation to use the latest URL format, which excludes the `.html` prefix. [(6412)](https://github.com/PennyLaneAI/pennylane/pull/6412)

* Update `qml.Qubitization` documentation based on new decomposition. [(6276)](https://github.com/PennyLaneAI/pennylane/pull/6276)

* Fixed examples in the documentation of a few optimizers. [(6303)](https://github.com/PennyLaneAI/pennylane/pull/6303) [(#6315)](https://github.com/PennyLaneAI/pennylane/pull/6315)

* Corrected examples in the documentation of `qml.jacobian`. [(6283)](https://github.com/PennyLaneAI/pennylane/pull/6283) [(#6315)](https://github.com/PennyLaneAI/pennylane/pull/6315)

* Fixed spelling in a number of places across the documentation. [(6280)](https://github.com/PennyLaneAI/pennylane/pull/6280)

* Add `work_wires` parameter to `qml.MultiControlledX` docstring signature. [(6271)](https://github.com/PennyLaneAI/pennylane/pull/6271)

* Removed ambiguity in error raised by the `PauliRot` class. [(6298)](https://github.com/PennyLaneAI/pennylane/pull/6298)

* Renamed an incorrectly named test in `test_pow_ops.py`. [(6388)](https://github.com/PennyLaneAI/pennylane/pull/6388)

* Removed outdated Docker description from installation page. [(6487)](https://github.com/PennyLaneAI/pennylane/pull/6487)

<h3>Bug fixes 🐛</h3>

* The wire order for `Snapshot`'s now matches the wire order of the device, rather than the simulation. [(6461)](https://github.com/PennyLaneAI/pennylane/pull/6461)

* Fixed a bug where `QNSPSAOptimizer`, `QNGOptimizer` and `MomentumQNGOptimizer` calculate invalid parameter updates if the metric tensor becomes singular. [(6471)](https://github.com/PennyLaneAI/pennylane/pull/6471)

* The `default.qubit` device now supports parameter broadcasting with `qml.classical_shadow` and `qml.shadow_expval`. [(6301)](https://github.com/PennyLaneAI/pennylane/pull/6301)

* Fixed unnecessary call of `eigvals` in `qml.ops.op_math.decompositions.two_qubit_unitary.py` that was causing an error in VJP. Raises warnings to users if this essentially nondifferentiable module is used. [(6437)](https://github.com/PennyLaneAI/pennylane/pull/6437)

* Patches the `math` module to function with autoray 0.7.0. [(6429)](https://github.com/PennyLaneAI/pennylane/pull/6429)

* Fixed incorrect differentiation of `PrepSelPrep` when using `diff_method="parameter-shift"`. [(6423)](https://github.com/PennyLaneAI/pennylane/pull/6423)

* The `validate_device_wires` transform now raises an error if abstract wires are provided. [(6405)](https://github.com/PennyLaneAI/pennylane/pull/6405)

* Fixed `qml.math.expand_matrix` for qutrit and arbitrary qudit operators. [(6398)](https://github.com/PennyLaneAI/pennylane/pull/6398/)

* `MeasurementValue` now raises an error when it is used as a boolean. [(6386)](https://github.com/PennyLaneAI/pennylane/pull/6386)

* `default.qutrit` now returns integer samples. [(6385)](https://github.com/PennyLaneAI/pennylane/pull/6385)

* `adjoint_metric_tensor` now works with circuits containing state preparation operations. [(6358)](https://github.com/PennyLaneAI/pennylane/pull/6358)

* `quantum_fisher` now respects the classical Jacobian of QNodes. [(6350)](https://github.com/PennyLaneAI/pennylane/pull/6350)

* `qml.map_wires` can now be applied to a batch of tapes. [(6295)](https://github.com/PennyLaneAI/pennylane/pull/6295)

* Fixed float-to-complex casting in various places across PennyLane. [(6260)](https://github.com/PennyLaneAI/pennylane/pull/6260) [(#6268)](https://github.com/PennyLaneAI/pennylane/pull/6268)

* Fixed a bug where zero-valued JVPs were calculated wrongly in the presence of shot vectors. [(6219)](https://github.com/PennyLaneAI/pennylane/pull/6219)

* Fixed `qml.PrepSelPrep` template to work with `torch`. [(6191)](https://github.com/PennyLaneAI/pennylane/pull/6191)

* Fixed a bug where `qml.equal` now correctly compares `qml.PrepSelPrep` operators. [(6182)](https://github.com/PennyLaneAI/pennylane/pull/6182)

* The `qml.QSVT` template now orders the `projector` wires first and the `UA` wires second, which is the expected order of the decomposition. [(6212)](https://github.com/PennyLaneAI/pennylane/pull/6212)

* The `qml.Qubitization` template now orders the `control` wires first and the `hamiltonian` wires second, which is the expected according to other templates. [(6229)](https://github.com/PennyLaneAI/pennylane/pull/6229)

* Fixed a bug where a circuit using the `autograd` interface sometimes returns nested values that are not of the `autograd` interface. [(6225)](https://github.com/PennyLaneAI/pennylane/pull/6225)

* Fixed a bug where a simple circuit with no parameters or only builtin/NumPy arrays as parameters returns autograd tensors. [(6225)](https://github.com/PennyLaneAI/pennylane/pull/6225)

* `qml.pauli.PauliVSpace` now uses a more stable SVD-based linear independence check to avoid running into `LinAlgError: Singular matrix`. This stabilizes the usage of `qml.lie_closure`. It also introduces normalization of the basis vector's internal representation `_M` to avoid exploding coefficients. [(6232)](https://github.com/PennyLaneAI/pennylane/pull/6232)

* Fixed a bug where `csc_dot_product` is used during measurement for `Sum`/`Hamiltonian` that contains observables that does not define a sparse matrix. [(6278)](https://github.com/PennyLaneAI/pennylane/pull/6278) [(#6310)](https://github.com/PennyLaneAI/pennylane/pull/6310)

* Fixed a bug where `None` was added to the wires in `qml.PhaseAdder`, `qml.Adder` and `qml.OutAdder`. [(6360)](https://github.com/PennyLaneAI/pennylane/pull/6360)

* Fixed a test after updating to the nightly version of Catalyst. [(6362)](https://github.com/PennyLaneAI/pennylane/pull/6362)

* Fixed a bug where `CommutingEvolution` with a trainable `Hamiltonian` cannot be differentiated using parameter shift. [(6372)](https://github.com/PennyLaneAI/pennylane/pull/6372)

* Fixed a bug where `mitigate_with_zne` loses the `shots` information of the original tape. [(6444)](https://github.com/PennyLaneAI/pennylane/pull/6444)

* Fixed a bug where `default.tensor` raises an error when applying `Identity`/`GlobalPhase` on no wires, and `PauliRot`/`MultiRZ` on a single wire. [(6448)](https://github.com/PennyLaneAI/pennylane/pull/6448)

* Fixes a bug where applying `qml.ctrl` and `qml.adjoint` on an operator type instead of an operator instance results in extra operators in the queue. [(6284)](https://github.com/PennyLaneAI/pennylane/pull/6284)

<h3>Contributors ✍️</h3>

This release contains contributions from (in alphabetical order):

Guillermo Alonso, Utkarsh Azad, Oleksandr Borysenko, Astral Cai, Yushao Chen, Isaac De Vlugt, Diksha Dhawan, Lillian M. A. Frederiksen, Pietropaolo Frisoni, Emiliano Godinez, Anthony Hayes, Austin Huang, Soran Jahangiri, Jacob Kitchen, Korbinian Kottmann, Christina Lee, William Maxwell, Erick Ochoa Lopez, Lee J. O'Riordan, Mudit Pandey, Andrija Paurevic, Alex Preciado, Ashish Kanwar Singh, David Wierichs

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

<h4>Registers of wires 🧸</h4>

* A new function called `qml.registers` has been added that lets you seamlessly create registers of wires. [(5957)](https://github.com/PennyLaneAI/pennylane/pull/5957) [(#6102)](https://github.com/PennyLaneAI/pennylane/pull/6102)

Using registers, it is easier to build large algorithms and circuits by applying gates and operations to predefined collections of wires. With `qml.registers`, you can create registers of wires by providing a dictionary whose keys are register names and whose values are the number of wires in each register.

python
>>> wire_reg = qml.registers({"alice": 4, "bob": 3})
>>> wire_reg
{'alice': Wires([0, 1, 2, 3]), 'bob': Wires([4, 5, 6])}


The resulting data structure of `qml.registers` is a dictionary with the same register names as keys, but the values are `qml.wires.Wires` instances.

Nesting registers within other registers can be done by providing a nested dictionary, where the ordering of wire labels is based on the order of appearance and nestedness.

python
>>> wire_reg = qml.registers({"alice": {"alice1": 1, "alice2": 2}, "bob": {"bob1": 2, "bob2": 1}})
>>> wire_reg
{'alice1': Wires([0]), 'alice2': Wires([1, 2]), 'alice': Wires([0, 1, 2]), 'bob1': Wires([3, 4]), 'bob2': Wires([5]), 'bob': Wires([3, 4, 5])}


Since the values of the dictionary are `Wires` instances, their use within quantum circuits is very similar to that of a `list` of integers.

python
dev = qml.device("default.qubit")

qml.qnode(dev)
def circuit():
for w in wire_reg["alice"]:
qml.Hadamard(w)

for w in wire_reg["bob1"]:
qml.RX(0.1967, wires=w)

qml.CNOT(wires=[wire_reg["alice1"][0], wire_reg["bob2"][0]])

return [qml.expval(qml.Y(w)) for w in wire_reg["bob1"]]

print(qml.draw(circuit)())


pycon
0: ──H────────╭●─┤
1: ──H────────│──┤
2: ──H────────│──┤
3: ──RX(0.20)─│──┤ <Y>
4: ──RX(0.20)─│──┤ <Y>
5: ───────────╰X─┤


In tandem with `qml.registers`, we've also made the following improvements to `qml.wires.Wires`:

* `Wires` instances now have a more copy-paste friendly representation when printed. [(5958)](https://github.com/PennyLaneAI/pennylane/pull/5958)

python
>>> from pennylane.wires import Wires
>>> w = Wires([1, 2, 3])
>>> w
Wires([1, 2, 3])


* Python set-based combinations are now supported by `Wires`. [(5983)](https://github.com/PennyLaneAI/pennylane/pull/5983)

This new feature unlocks the ability to combine `Wires` instances in the following ways:

* intersection with `&` or `intersection()`:

python
>>> wires1 = Wires([1, 2, 3])
>>> wires2 = Wires([2, 3, 4])
>>> wires1.intersection(wires2) or wires1 & wires2
Wires([2, 3])


* symmetric difference with `^` or `symmetric_difference()`:

python
>>> wires1.symmetric_difference(wires2) or wires1 ^ wires2
Wires([1, 4])


* union with `|` or `union()`:

python
>>> wires1.union(wires2) or wires1 | wires2
Wires([1, 2, 3, 4])


* difference with `-` or `difference()`:

python
>>> wires1.difference(wires2) or wires1 - wires2
Wires([1])


<h4>Quantum arithmetic operations 🧮</h4>

* Several new operator templates have been added to PennyLane that let you perform quantum arithmetic operations. [(6109)](https://github.com/PennyLaneAI/pennylane/pull/6109) [(#6112)](https://github.com/PennyLaneAI/pennylane/pull/6112) [(#6121)](https://github.com/PennyLaneAI/pennylane/pull/6121)

* `qml.Adder` performs in-place modular addition: $\text{Adder}(k, m)\vert x \rangle = \vert x + k \; \text{mod} \; m\rangle$.

* `qml.PhaseAdder` is similar to `qml.Adder`, but it performs in-place modular addition in the Fourier basis.

* `qml.Multiplier` performs in-place multiplication: $\text{Multiplier}(k, m)\vert x \rangle = \vert x \times k \; \text{mod} \; m \rangle$.

* `qml.OutAdder` performs out-place modular addition: $\text{OutAdder}(m)\vert x \rangle \vert y \rangle \vert b \rangle = \vert x \rangle \vert y \rangle \vert b + x + y \; \text{mod} \; m \rangle$.

* `qml.OutMultiplier` performs out-place modular multiplication: $\text{OutMultiplier}(m)\vert x \rangle \vert y \rangle \vert b \rangle = \vert x \rangle \vert y \rangle \vert b + x \times y \; \text{mod} \; m \rangle$.

* `qml.ModExp` performs modular exponentiation: $\text{ModExp}(base, m) \vert x \rangle \vert k \rangle = \vert x \rangle \vert k \times base^x \; \text{mod} \; m \rangle$.

Here is a comprehensive example that performs the following calculation: `(2 + 1) * 3 mod 7 = 2` (or `010` in binary).

python
dev = qml.device("default.qubit", shots=1)

wire_reg = qml.registers({
"x_wires": 2, |x>: stores the result of 2 + 1 = 3
"y_wires": 2, |y>: multiples x by 3
"output_wires": 3, stores the result of (2 + 1) * 3 m 7 = 2
"work_wires": 2 for qml.OutMultiplier
})

qml.qnode(dev)
def circuit():
In-place addition
qml.BasisEmbedding(2, wires=wire_reg["x_wires"])
qml.Adder(1, x_wires=wire_reg["x_wires"]) add 1 to wires [0, 1]

Out-place multiplication
qml.BasisEmbedding(3, wires=wire_reg["y_wires"])
qml.OutMultiplier(
wire_reg["x_wires"],
wire_reg["y_wires"],
wire_reg["output_wires"],
work_wires=wire_reg["work_wires"],
mod=7
)

return qml.sample(wires=wire_reg["output_wires"])



>>> circuit()
array([0, 1, 0])


<h4>Converting noise models from Qiskit ♻️</h4>

* Convert Qiskit noise models into a PennyLane `NoiseModel` with `qml.from_qiskit_noise`. [(5996)](https://github.com/PennyLaneAI/pennylane/pull/5996)

In the last few releases, we've added substantial improvements and new features to the [Pennylane-Qiskit plugin](https://docs.pennylane.ai/projects/qiskit/en/latest/installation.html). With this release, a new `qml.from_qiskit_noise` function allows you to convert a Qiskit noise model into a PennyLane `NoiseModel`. Here is a simple example with two quantum errors that add two different depolarizing errors based on the presence of different gates in the circuit:

python
import pennylane as qml
import qiskit_aer.noise as noise

error_1 = noise.depolarizing_error(0.001, 1) 1-qubit noise
error_2 = noise.depolarizing_error(0.01, 2) 2-qubit noise

noise_model = noise.NoiseModel()

noise_model.add_all_qubit_quantum_error(error_1, ['rz', 'ry'])
noise_model.add_all_qubit_quantum_error(error_2, ['cx'])


pycon
>>> qml.from_qiskit_noise(noise_model)
NoiseModel({
OpIn(['RZ', 'RY']): QubitChannel(num_kraus=4, num_wires=1)
OpIn(['CNOT']): QubitChannel(num_kraus=16, num_wires=2)
})


Under the hood, PennyLane converts each quantum error in the Qiskit noise model into an equivalent `qml.QubitChannel` operator with the same canonical [Kraus representation](https://en.wikipedia.org/wiki/Quantum_operation#Kraus_operators). Currently, noise models in PennyLane do not support readout errors. As such, those will be skipped during conversion if they are present in the Qiskit noise model.

Make sure to `pip install pennylane-qiskit` to access this new feature!

<h4>Substantial upgrades to mid-circuit measurements using tree-traversal 🌳</h4>

* The `"tree-traversal"` algorithm for mid-circuit measurements (MCMs) on `default.qubit` has been internally redesigned for better performance. [(5868)](https://github.com/PennyLaneAI/pennylane/pull/5868)

In the last release (v0.37), we introduced the tree-traversal MCM method, which was implemented in a recursive way for simplicity. However, this had the unintended consequence of very deep [stack calls](https://en.wikipedia.org/wiki/Call_stack) for circuits with many MCMs, resulting in [stack overflows](https://en.wikipedia.org/wiki/Stack_overflow) in some cases. With this release, we've refactored the implementation of the tree-traversal method into an iterative approach, which solves those inefficiencies when many MCMs are present in a circuit.

* The `tree-traversal` algorithm is now compatible with analytic-mode execution (`shots=None`). [(5868)](https://github.com/PennyLaneAI/pennylane/pull/5868)

python
dev = qml.device("default.qubit")

n_qubits = 5

qml.qnode(dev, mcm_method="tree-traversal")
def circuit():
for w in range(n_qubits):
qml.Hadamard(w)

for w in range(n_qubits - 1):
qml.CNOT(wires=[w, w+1])

for w in range(n_qubits):
m = qml.measure(w)
qml.cond(m == 1, qml.RX)(0.1967 * (w + 1), w)

return [qml.expval(qml.Z(w)) for w in range(n_qubits)]


pycon
>>> circuit()
[tensor(0.00964158, requires_grad=True),
tensor(0.03819446, requires_grad=True),
tensor(0.08455748, requires_grad=True),
tensor(0.14694258, requires_grad=True),
tensor(0.2229438, requires_grad=True)]


<h3>Improvements 🛠</h3>

<h4>Creating spin Hamiltonians</h4>

* Three new functions are now available for creating commonly-used spin Hamiltonians in PennyLane: [(6106)](https://github.com/PennyLaneAI/pennylane/pull/6106) [(#6128)](https://github.com/PennyLaneAI/pennylane/pull/6128)

* `qml.spin.transverse_ising` creates the [transverse-field Ising model](https://en.wikipedia.org/wiki/Transverse-field_Ising_model) Hamiltonian.
* `qml.spin.heisenberg` creates the [Heisenberg model](https://en.wikipedia.org/wiki/Quantum_Heisenberg_model) Hamiltonian.
* `qml.spin.fermi_hubbard` creates the [Fermi-Hubbard model](https://en.wikipedia.org/wiki/Hubbard_model) Hamiltonian.

Each Hamiltonian can be instantiated by specifying a `lattice`, the number of [unit cells](https://en.wikipedia.org/wiki/Unit_cell), `n_cells`, and the Hamiltonian parameters as keyword arguments. Here is an example with the transverse-field Ising model:

pycon
>>> tfim_ham = qml.spin.transverse_ising(lattice="square", n_cells=[2, 2], coupling=0.5, h=0.2)
>>> tfim_ham
(
-0.5 * (Z(0) Z(1))
+ -0.5 * (Z(0) Z(2))
+ -0.5 * (Z(1) Z(3))
+ -0.5 * (Z(2) Z(3))
+ -0.2 * X(0)
+ -0.2 * X(1)
+ -0.2 * X(2)
+ -0.2 * X(3)
)


The resulting object is a `qml.Hamiltonian` instance, making it easy to use in circuits like the following.

python
dev = qml.device("default.qubit", shots=1)

qml.qnode(dev)
def circuit():
return qml.expval(tfim_ham)



>>> circuit()
-2.0


More features will be added to the `qml.spin` module in the coming releases, so stay tuned!

<h4>A Prep-Select-Prep template</h4>

* A new template called `qml.PrepSelPrep` has been added that implements a block-encoding of a linear combination of unitaries. [(5756)](https://github.com/PennyLaneAI/pennylane/pull/5756) [(#5987)](https://github.com/PennyLaneAI/pennylane/pull/5987)

This operator acts as a nice wrapper for having to perform `qml.StatePrep`, `qml.Select`, and `qml.adjoint(qml.StatePrep)` in succession, which is quite common in many quantum algorithms (e.g., [LCU and block encoding](https://pennylane.ai/qml/demos/tutorial_lcu_blockencoding/)). Here is an example showing the equivalence between using `qml.PrepSelPrep` and `qml.StatePrep`, `qml.Select`, and `qml.adjoint(qml.StatePrep)`.

python
coeffs = [0.3, 0.1]
alphas = (np.sqrt(coeffs) / np.linalg.norm(np.sqrt(coeffs)))
unitaries = [qml.X(2), qml.Z(2)]

lcu = qml.dot(coeffs, unitaries)
control = [0, 1]

def prep_sel_prep(alphas, unitaries):
qml.StatePrep(alphas, wires=control, pad_with=0)
qml.Select(unitaries, control=control)
qml.adjoint(qml.StatePrep)(alphas, wires=control, pad_with=0)

qml.qnode(qml.device("default.qubit"))
def circuit(lcu, control, alphas, unitaries):
qml.PrepSelPrep(lcu, control)
qml.adjoint(prep_sel_prep)(alphas, unitaries)
return qml.state()


pycon
>>> import numpy as np
>>> np.round(circuit(lcu, control, alphas, unitaries), decimals=2)
tensor([1.+0.j -0.+0.j -0.+0.j -0.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j], requires_grad=True)


<h4>QChem improvements</h4>

* Molecules and Hamiltonians can now be constructed for all the elements present in the periodic table. [(5821)](https://github.com/PennyLaneAI/pennylane/pull/5821)

This new feature is made possible by integrating with the [basis-set-exchange package](https://pypi.org/project/basis-set-exchange/). If loading basis sets from `basis-set-exchange` is needed for your molecule, make sure that you `pip install basis-set-exchange` and set `load_data=True`.

python
symbols = ['Ti', 'Ti']
geometry = np.array([[0.0, 0.0, -1.1967],
[0.0, 0.0, 1.1967]], requires_grad=True)
mol = qml.qchem.Molecule(symbols, geometry, load_data=True)


pycon
>>> mol.n_electrons
44


* `qml.UCCSD` now accepts an additional optional argument, `n_repeats`, which defines the number of times the UCCSD template is repeated. This can improve the accuracy of the template by reducing the Trotter error, but would result in deeper circuits. [(5801)](https://github.com/PennyLaneAI/pennylane/pull/5801)

* The `qml.qchem.qubit_observable` function has been modified to return an ascending wire order for molecular Hamiltonians. [(5950)](https://github.com/PennyLaneAI/pennylane/pull/5950)

* A new method called `to_mat` has been added to the `qml.FermiWord` and `qml.FermiSentence` classes, which allows for computing the matrix representation of these Fermi operators. [(5920)](https://github.com/PennyLaneAI/pennylane/pull/5920)

<h4>Improvements to operators</h4>

* `qml.GlobalPhase` now supports parameter broadcasting. [(5923)](https://github.com/PennyLaneAI/pennylane/pull/5923)

* `qml.Hermitian` now has a `compute_decomposition` method. [(6062)](https://github.com/PennyLaneAI/pennylane/pull/6062)

* The implementation of `qml.PhaseShift`, `qml.S`, and `qml.T` has been improved, resulting in faster circuit execution times. [(5876)](https://github.com/PennyLaneAI/pennylane/pull/5876)

* The `qml.CNOT` operator no longer decomposes into itself. Instead, it raises a `qml.DecompositionUndefinedError`. [(6039)](https://github.com/PennyLaneAI/pennylane/pull/6039)

<h4>Mid-circuit measurements</h4>

* The `qml.dynamic_one_shot` transform now supports circuits using the `"tensorflow"` interface. [(5973)](https://github.com/PennyLaneAI/pennylane/pull/5973)

* If the conditional does not include a mid-circuit measurement, then `qml.cond` will automatically evaluate conditionals using standard Python control flow. [(6016)](https://github.com/PennyLaneAI/pennylane/pull/6016)

This allows `qml.cond` to be used to represent a wider range of conditionals:

python
dev = qml.device("default.qubit", wires=1)

qml.qnode(dev)
def circuit(x):
c = qml.cond(x > 2.7, qml.RX, qml.RZ)
c(x, wires=0)
return qml.probs(wires=0)


pycon
>>> print(qml.draw(circuit)(3.8))
0: ──RX(3.80)─┤ Probs
>>> print(qml.draw(circuit)(0.54))
0: ──RZ(0.54)─┤ Probs


<h4>Transforms</h4>

* `qml.transforms.single_qubit_fusion` and `qml.transforms.merge_rotations` now respect global phases. [(6031)](https://github.com/PennyLaneAI/pennylane/pull/6031)

* A new transform called `qml.transforms.diagonalize_measurements` has been added. This transform converts measurements to the computational basis by applying the relevant diagonalizing gates. It can be set to diagonalize only a subset of the base observables `{qml.X, qml.Y, qml.Z, qml.Hadamard}`. [(5829)](https://github.com/PennyLaneAI/pennylane/pull/5829)

* A new transform called `split_to_single_terms` has been added. This transform splits expectation values of sums into multiple single-term measurements on a single tape, providing better support for simulators that can handle non-commuting observables but don't natively support multi-term observables. [(5884)](https://github.com/PennyLaneAI/pennylane/pull/5884)

* New functionality has been added to natively support exponential extrapolation when using `qml.transforms.mitigate_with_zne`. This allows users to have more control over the error mitigation protocol without needing to add further dependencies. [(5972)](https://github.com/PennyLaneAI/pennylane/pull/5972)

<h4>Capturing and representing hybrid programs</h4>

* `qml.for_loop` now supports `range`-like syntax with default `step=1`. [(6068)](https://github.com/PennyLaneAI/pennylane/pull/6068)

* Applying `adjoint` and `ctrl` to a quantum function can now be captured into plxpr. Furthermore, the `qml.cond` function can be captured into plxpr. [(5966)](https://github.com/PennyLaneAI/pennylane/pull/5966) [(#5967)](https://github.com/PennyLaneAI/pennylane/pull/5967) [(#5999)](https://github.com/PennyLaneAI/pennylane/pull/5999) [(#6058)](https://github.com/PennyLaneAI/pennylane/pull/6058)

* During experimental program capture, functions that accept and/or return `pytree` structures can now be handled in the `qml.QNode` call, `qml.cond`, `qml.for_loop` and `qml.while_loop`. [(6081)](https://github.com/PennyLaneAI/pennylane/pull/6081)

* During experimental program capture, QNodes can now use closure variables. [(6052)](https://github.com/PennyLaneAI/pennylane/pull/6052)

* Mid-circuit measurements can now be captured with `qml.capture` enabled. [(6015)](https://github.com/PennyLaneAI/pennylane/pull/6015)

* `qml.for_loop` can now be captured into plxpr. [(6041)](https://github.com/PennyLaneAI/pennylane/pull/6041) [(#6064)](https://github.com/PennyLaneAI/pennylane/pull/6064)

* `qml.for_loop` and `qml.while_loop` now fall back to standard Python control flow if `qjit` is not present, allowing the same code to work with and without `qjit` without any rewrites. [(6014)](https://github.com/PennyLaneAI/pennylane/pull/6014)

python
dev = qml.device("lightning.qubit", wires=3)

qml.qnode(dev)
def circuit(x, n):

qml.for_loop(0, n, 1)
def init_state(i):
qml.Hadamard(wires=i)

init_state()

qml.for_loop(0, n, 1)
def apply_operations(i, x):
qml.RX(x, wires=i)

qml.for_loop(i + 1, n, 1)
def inner(j):
qml.CRY(x**2, [i, j])

inner()
return jnp.sin(x)

apply_operations(x)
return qml.probs()


pycon
>>> print(qml.draw(circuit)(0.5, 3))
0: ──H──RX(0.50)─╭●────────╭●──────────────────────────────────────┤ Probs
1: ──H───────────╰RY(0.25)─│──────────RX(0.48)─╭●──────────────────┤ Probs
2: ──H─────────────────────╰RY(0.25)───────────╰RY(0.23)──RX(0.46)─┤ Probs
>>> circuit(0.5, 3)
array([0.125 , 0.125 , 0.09949758, 0.15050242, 0.07594666,
0.11917543, 0.08942104, 0.21545687])
>>> qml.qjit(circuit)(0.5, 3)
Array([0.125 , 0.125 , 0.09949758, 0.15050242, 0.07594666,
0.11917543, 0.08942104, 0.21545687], dtype=float64)


<h4>Community contributions 🥳</h4>

* Fixed a bug in `qml.ThermalRelaxationError` where there was a typo from `tq` to `tg`. [(5988)](https://github.com/PennyLaneAI/pennylane/issues/5988)

* Readout error has been added using parameters `readout_relaxation_probs` and `readout_misclassification_probs` on the `default.qutrit.mixed` device. These parameters add a `qml.QutritAmplitudeDamping` and a `qml.TritFlip` channel, respectively, after measurement diagonalization. The amplitude damping error represents the potential for relaxation to occur during longer measurements. The trit flip error represents misclassification during readout. [(5842)](https://github.com/PennyLaneAI/pennylane/pull/5842)

* `qml.ops.qubit.BasisStateProjector` now has a `compute_sparse_matrix` method that computes the sparse CSR matrix representation of the projector onto the given basis state. [(5790)](https://github.com/PennyLaneAI/pennylane/pull/5790)

<h4>Other improvements</h4>

* `qml.pauli.group_observables` now uses `rustworkx` colouring algorithms to solve the [Minimum Clique Cover problem](https://en.wikipedia.org/wiki/Clique_cover), resulting in orders of magnitude performance improvements. [(#6043)](https://github.com/PennyLaneAI/pennylane/pull/6043)

This adds two new options for the `method` argument: `dsatur` (degree of saturation) and `gis` (independent set). In addition, the creation of the adjacency matrix now takes advantage of the symplectic representation of the Pauli observables.

Additionally, a new function called `qml.pauli.compute_partition_indices` has been added to calculate the indices from the partitioned observables more efficiently. These changes improve the wall time of `qml.LinearCombination.compute_grouping` and the `grouping_type='qwc'` by orders of magnitude.

* `qml.counts` measurements with `all_outcomes=True` can now be used with JAX jitting. Additionally, measurements broadcasted across all available wires (e.g., `qml.probs()`) can now be used with JAX jit and devices that allow dynamic numbers of wires (only `'default.qubit'` currently). [(6108)](https://github.com/PennyLaneAI/pennylane/pull/6108/)

* `qml.ops.op_math.ctrl_decomp_zyz` can now decompose special unitaries with multiple control wires. [(6042)](https://github.com/PennyLaneAI/pennylane/pull/6042)

* A new method called `process_density_matrix` has been added to the `ProbabilityMP` and `DensityMatrixMP` measurement processes, allowing for more efficient handling of quantum density matrices, particularly with batch processing support. This method simplifies the calculation of probabilities from quantum states represented as density matrices. [(5830)](https://github.com/PennyLaneAI/pennylane/pull/5830)

* `SProd.terms` now flattens out the terms if the base is a multi-term observable. [(5885)](https://github.com/PennyLaneAI/pennylane/pull/5885)

* `qml.QNGOptimizer` now supports cost functions with multiple arguments, updating each argument independently. [(5926)](https://github.com/PennyLaneAI/pennylane/pull/5926)

* `semantic_version` has been removed from the list of required packages in PennyLane. [(5836)](https://github.com/PennyLaneAI/pennylane/pull/5836)

* `qml.devices.LegacyDeviceFacade` has been added to map the legacy devices to the new device interface, making it easier for developers to develop legacy devices. [(5927)](https://github.com/PennyLaneAI/pennylane/pull/5927)

* `StateMP.process_state` now defines rules in `cast_to_complex` for complex casting, avoiding a superfluous statevector copy in PennyLane-Lightning simulations. [(5995)](https://github.com/PennyLaneAI/pennylane/pull/5995)

* `QuantumScript.hash` is now cached, leading to performance improvements. [(5919)](https://github.com/PennyLaneAI/pennylane/pull/5919)

* Observable validation for `default.qubit` is now based on execution mode (analytic vs. finite shots) and measurement type (sample measurement vs. state measurement). This improves our error handling when, for example, non-hermitian operators are given to `qml.expval`. [(5890)](https://github.com/PennyLaneAI/pennylane/pull/5890)

* A new `is_leaf` parameter has been added to the function `flatten` in the `qml.pytrees` module. This is to allow for node flattening to be stopped for any node where the `is_leaf` optional argument evaluates to being `True`. [(6107)](https://github.com/PennyLaneAI/pennylane/issues/6107)

* A progress bar has been added to `qml.data.load()` when downloading a dataset. [(5560)](https://github.com/PennyLaneAI/pennylane/pull/5560)

* Upgraded and simplified `StatePrep` and `AmplitudeEmbedding` templates. [(6034)](https://github.com/PennyLaneAI/pennylane/pull/6034) [(#6170)](https://github.com/PennyLaneAI/pennylane/pull/6170)

* Upgraded and simplified `BasisState` and `BasisEmbedding` templates. [(6021)](https://github.com/PennyLaneAI/pennylane/pull/6021)

<h3>Breaking changes 💔</h3>

* `MeasurementProcess.shape(shots: Shots, device:Device)` is now `MeasurementProcess.shape(shots: Optional[int], num_device_wires:int = 0)`. This has been done to allow for jitting when a measurement is broadcasted across all available wires, but the device does not specify wires. [(6108)](https://github.com/PennyLaneAI/pennylane/pull/6108/)

* If the shape of a probability measurement is affected by a `Device.cutoff` property, it will no longer work with jitting. [(6108)](https://github.com/PennyLaneAI/pennylane/pull/6108/)

* `qml.GlobalPhase` is considered non-differentiable with tape transforms. As a consequence, `qml.gradients.finite_diff` and `qml.gradients.spsa_grad` no longer support differentiating `qml.GlobalPhase` with state-based outputs. [(5620)](https://github.com/PennyLaneAI/pennylane/pull/5620)

* The `CircuitGraph.graph` `rustworkx` graph now stores indices into the circuit as the node labels, instead of the operator/ measurement itself. This allows the same operator to occur multiple times in the circuit. [(5907)](https://github.com/PennyLaneAI/pennylane/pull/5907)

* The `queue_idx` attribute has been removed from the `Operator`, `CompositeOp`, and `SymbolicOp` classes. [(6005)](https://github.com/PennyLaneAI/pennylane/pull/6005)

* `qml.from_qasm` no longer removes measurements from the QASM code. Use `measurements=[]` to remove measurements from the original circuit. [(5982)](https://github.com/PennyLaneAI/pennylane/pull/5982)

* `qml.transforms.map_batch_transform` has been removed, since transforms can be applied directly to a batch of tapes. See `qml.transform` for more information. [(5981)](https://github.com/PennyLaneAI/pennylane/pull/5981)

* `QuantumScript.interface` has been removed. [(5980)](https://github.com/PennyLaneAI/pennylane/pull/5980)

<h3>Deprecations 👋</h3>

* The `decomp_depth` argument in `qml.device` has been deprecated. [(6026)](https://github.com/PennyLaneAI/pennylane/pull/6026)

* The `max_expansion` argument in `qml.QNode` has been deprecated. [(6026)](https://github.com/PennyLaneAI/pennylane/pull/6026)

* The `expansion_strategy` attribute `qml.QNode` has been deprecated. [(5989)](https://github.com/PennyLaneAI/pennylane/pull/5989)

* The `expansion_strategy` argument has been deprecated in all of `qml.draw`, `qml.draw_mpl`, and `qml.specs`. The `level` argument should be used instead. [(5989)](https://github.com/PennyLaneAI/pennylane/pull/5989)

* `Operator.expand` has been deprecated. Users should simply use `qml.tape.QuantumScript(op.decomposition())` for equivalent behaviour. [(5994)](https://github.com/PennyLaneAI/pennylane/pull/5994)

* `qml.transforms.sum_expand` and `qml.transforms.hamiltonian_expand` have been deprecated. Users should instead use `qml.transforms.split_non_commuting` for equivalent behaviour. [(6003)](https://github.com/PennyLaneAI/pennylane/pull/6003)

* The `expand_fn` argument in `qml.execute` has been deprecated. Instead, please create a `qml.transforms.core.TransformProgram` with the desired preprocessing and pass it to the `transform_program` argument of `qml.execute`. [(5984)](https://github.com/PennyLaneAI/pennylane/pull/5984)

* The `max_expansion` argument in `qml.execute` has been deprecated. Instead, please use `qml.devices.preprocess.decompose` with the desired expansion level, add it to a `qml.transforms.core.TransformProgram` and pass it to the `transform_program` argument of `qml.execute`. [(5984)](https://github.com/PennyLaneAI/pennylane/pull/5984)

* The `override_shots` argument in `qml.execute` has been deprecated. Instead, please add the shots to the `QuantumTape`s to be executed. [(5984)](https://github.com/PennyLaneAI/pennylane/pull/5984)

* The `device_batch_transform` argument in `qml.execute` has been deprecated. Instead, please create a `qml.transforms.core.TransformProgram` with the desired preprocessing and pass it to the `transform_program` argument of `qml.execute`. [(5984)](https://github.com/PennyLaneAI/pennylane/pull/5984)

* `qml.qinfo.classical_fisher` and `qml.qinfo.quantum_fisher` have been deprecated. Instead, use `qml.gradients.classical_fisher` and `qml.gradients.quantum_fisher`. [(5985)](https://github.com/PennyLaneAI/pennylane/pull/5985)

* The legacy devices `default.qubit.{autograd,torch,tf,jax,legacy}` have been deprecated. Instead, use `default.qubit`, as it now supports backpropagation through the several backends. [(5997)](https://github.com/PennyLaneAI/pennylane/pull/5997)

* The logic for internally switching a device for a different backpropagation compatible device is now deprecated, as it was in place for the deprecated `default.qubit.legacy`. [(6032)](https://github.com/PennyLaneAI/pennylane/pull/6032)

<h3>Documentation 📝</h3>

* The docstring for `qml.qinfo.quantum_fisher`, regarding the internally used functions and potentially required auxiliary wires, has been improved. [(6074)](https://github.com/PennyLaneAI/pennylane/pull/6074)

* The docstring for `QuantumScript.expand` and `qml.tape.tape.expand_tape` has been improved. [(5974)](https://github.com/PennyLaneAI/pennylane/pull/5974)

<h3>Bug fixes 🐛</h3>

* The sparse matrix can now be computed for a product operator when one operand is a `GlobalPhase` on no wires. [(6197)](https://github.com/PennyLaneAI/pennylane/pull/6197)

* For `default.qubit`, JAX is now used for sampling whenever the state is a JAX array. This fixes normalization issues that can occur when the state uses 32-bit precision. [(6190)](https://github.com/PennyLaneAI/pennylane/pull/6190)

* Fix Pytree serialization of operators with empty shot vectors [(6155)](https://github.com/PennyLaneAI/pennylane/pull/6155)

* Fixes an error in the `dynamic_one_shot` transform when used with sampling a single shot. [(6149)](https://github.com/PennyLaneAI/pennylane/pull/6149)

* `qml.transforms.pattern_matching_optimization` now preserves the tape measurements. [(6153)](https://github.com/PennyLaneAI/pennylane/pull/6153)

* `qml.transforms.broadcast_expand` no longer squeezes out batch sizes of size 1, as a batch size of 1 is still a batch size. [(6147)](https://github.com/PennyLaneAI/pennylane/pull/6147)

* Catalyst replaced `argnum` with `argnums` in gradient related functions, therefore we updated the Catalyst calls to those functions in PennyLane. [(6117)](https://github.com/PennyLaneAI/pennylane/pull/6117)

* `fuse_rot_angles` now returns NaN instead of incorrect derivatives at singular points. [(6031)](https://github.com/PennyLaneAI/pennylane/pull/6031)

* `qml.GlobalPhase` and `qml.Identity` can now be captured with plxpr when acting on no wires. [(6060)](https://github.com/PennyLaneAI/pennylane/pull/6060)

* Fixed `jax.grad` and `jax.jit` to work for `qml.AmplitudeEmbedding`, `qml.StatePrep` and `qml.MottonenStatePreparation`. [(5620)](https://github.com/PennyLaneAI/pennylane/pull/5620)

* Fixed a bug in `qml.center` that omitted elements from the center if they were linear combinations of input elements. [(6049)](https://github.com/PennyLaneAI/pennylane/pull/6049)

* Fix a bug where the global phase returned by `one_qubit_decomposition` gained a broadcasting dimension. [(5923)](https://github.com/PennyLaneAI/pennylane/pull/5923)

* Fixed a bug in `qml.SPSAOptimizer` that ignored keyword arguments in the objective function. [(6027)](https://github.com/PennyLaneAI/pennylane/pull/6027)

* Fixed `dynamic_one_shot` for use with devices using the old device API, since `override_shots` was deprecated. [(6024)](https://github.com/PennyLaneAI/pennylane/pull/6024)

* `CircuitGraph` can now handle circuits with the same operation instance occuring multiple times. [(5907)](https://github.com/PennyLaneAI/pennylane/pull/5907)

* `qml.QSVT` has been updated to store wire order correctly. [(5959)](https://github.com/PennyLaneAI/pennylane/pull/5959)

* `qml.devices.qubit.measure_with_samples` now returns the correct result if the provided measurements contain a sum of operators acting on the same wire. [(5978)](https://github.com/PennyLaneAI/pennylane/pull/5978)

* `qml.AmplitudeEmbedding` has better support for features using low precision integer data types. [(5969)](https://github.com/PennyLaneAI/pennylane/pull/5969)

* `qml.BasisState` and `qml.BasisEmbedding` now works with jax.jit, `lightning.qubit`, and give the correct decomposition. [(6021)](https://github.com/PennyLaneAI/pennylane/pull/6021)

* Jacobian shape has been fixed for measurements with dimension in `qml.gradients.vjp.compute_vjp_single`. [(5986)](https://github.com/PennyLaneAI/pennylane/pull/5986)

* `qml.lie_closure` now works with sums of Paulis. [(6023)](https://github.com/PennyLaneAI/pennylane/pull/6023)

* Workflows that parameterize the coefficients of `qml.exp` are now jit-compatible. [(6082)](https://github.com/PennyLaneAI/pennylane/pull/6082)

* Fixed a bug where `CompositeOp.overlapping_ops` changes the original ordering of operators, causing an incorrect matrix to be generated for `Prod` with `Sum` as operands. [(6091)](https://github.com/PennyLaneAI/pennylane/pull/6091)

* `qml.qsvt` now works with "Wx" convention and any number of angles. [(6105)](https://github.com/PennyLaneAI/pennylane/pull/6105)

* Basis set data from the Basis Set Exchange library can now be loaded for elements with `SPD`-type orbitals. [(6159)](https://github.com/PennyLaneAI/pennylane/pull/6159)

<h3>Contributors ✍️</h3>

This release contains contributions from (in alphabetical order):

Tarun Kumar Allamsetty, Guillermo Alonso, Ali Asadi, Utkarsh Azad, Tonmoy T. Bhattacharya, Gabriel Bottrill, Jack Brown, Ahmed Darwish, Astral Cai, Yushao Chen, Ahmed Darwish, Diksha Dhawan Maja Franz, Lillian M. A. Frederiksen, Pietropaolo Frisoni, Emiliano Godinez, Austin Huang, Renke Huang, Josh Izaac, Soran Jahangiri, Korbinian Kottmann, Christina Lee, Jorge Martinez de Lejarza, William Maxwell, Vincent Michaud-Rioux, Anurav Modak, Mudit Pandey, Andrija Paurevic, Erik Schultheis, nate stemen, David Wierichs,

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

<h4>Execute wide circuits with Default Tensor 🔗</h4>

* A new `default.tensor` device is now available for performing [tensor network](https://en.wikipedia.org/wiki/Tensor_network) and [matrix product state](https://en.wikipedia.org/wiki/Matrix_product_state) simulations of quantum circuits using the [quimb backend](https://quimb.readthedocs.io/en/latest/). [(#5699)](https://github.com/PennyLaneAI/pennylane/pull/5699) [(#5744)](https://github.com/PennyLaneAI/pennylane/pull/5744) [(#5786)](https://github.com/PennyLaneAI/pennylane/pull/5786) [(#5795)](https://github.com/PennyLaneAI/pennylane/pull/5795)

Either method can be selected when instantiating the `default.tensor` device by setting the `method` keyword argument to `"tn"` (tensor network) or `"mps"` (matrix product state).

There are [several templates in PennyLane](https://docs.pennylane.ai/en/stable/introduction/templates.html#tensor-networks) that are tensor-network focused, which are excellent candidates for the `"tn"` method for `default.tensor`. The following example shows how a circuit comprising gates in a tree tensor network architecture can be efficiently simulated using `method="tn"`.

python
import pennylane as qml

n_wires = 16
dev = qml.device("default.tensor", method="tn")

def block(weights, wires):
qml.CNOT(wires=[wires[0], wires[1]])
qml.RY(weights[0], wires=wires[0])
qml.RY(weights[1], wires=wires[1])

n_block_wires = 2
n_params_block = 2
n_blocks = qml.TTN.get_n_blocks(range(n_wires), n_block_wires)
template_weights = [[0.1, -0.3]] * n_blocks

qml.qnode(dev)
def circuit(template_weights):
for i in range(n_wires):
qml.Hadamard(i)
qml.TTN(range(n_wires), n_block_wires, block, n_params_block, template_weights)
return qml.expval(qml.Z(n_wires - 1))


pycon
>>> circuit(template_weights)
0.3839174759751649


For matrix product state simulations (`method="mps"`), we can make the execution be approximate by setting `max_bond_dim` (see the [device's documentation](https://docs.pennylane.ai/en/stable/code/api/pennylane.devices.default_tensor.DefaultTensor.html) for more details). The maximum bond dimension has implications for the speed of the simulation and lets us control the degree of the approximation, as shown in the following example. First, set up the circuit:

python
import numpy as np

n_layers = 10
n_wires = 10
initial_shape, weights_shape = qml.SimplifiedTwoDesign.shape(n_layers, n_wires)
np.random.seed(1967)
initial_layer_weights = np.random.random(initial_shape)
weights = np.random.random(weights_shape)

def f():
qml.SimplifiedTwoDesign(initial_layer_weights, weights, range(n_wires))
return qml.expval(qml.Z(0))


The `default.tensor` device is instantiated with a `max_bond_dim` value:

python
dev_dq = qml.device("default.qubit")
value_dq = qml.QNode(f, dev_dq)()

dev_mps = qml.device("default.tensor", max_bond_dim=5)
value_mps = qml.QNode(f, dev_mps)()


With this bond dimension, the expectation values calculated for `default.qubit` and `default.tensor` are different:

pycon
>>> np.abs(value_dq - value_mps)
tensor(0.0253213, requires_grad=True)


Learn more about `default.tensor` and how to configure it by [visiting the how-to guide](https://pennylane.ai/qml/demos/tutorial_How_to_simulate_quantum_circuits_with_tensor_networks/).

<h4>Add noise models to your quantum circuits 📺</h4>

* Support for building noise models and applying them to a quantum circuit has been added via the `NoiseModel` class and an `add_noise` transform. [(5674)](https://github.com/PennyLaneAI/pennylane/pull/5674) [(#5684)](https://github.com/PennyLaneAI/pennylane/pull/5684) [(#5718)](https://github.com/PennyLaneAI/pennylane/pull/5718)

Under the hood, PennyLane's approach to noise models is insertion-based, meaning that noise is included by *inserting* additional operators (gates or channels) that describe the noise into the quantum circuit. Creating a `NoiseModel` boils down to defining Boolean conditions under which specific noisy operations are inserted. There are several ways to specify conditions for adding noisy operations:

* `qml.noise.op_eq(op)`: if the operator `op` is encountered in the circuit, add noise.
* `qml.noise.op_in(ops)`: if any operators in `ops` are encountered in the circuit, add noise.
* `qml.noise.wires_eq(wires)`: if an operator is applied to `wires`, add noise.
* `qml.noise.wires_in(wires)`: if an operator is applied to any wire in `wires`, add noise.
* custom noise conditions: custom conditions can be defined as functions decorated with `qml.BooleanFn` that return a Boolean value. For example, the following function will insert noise if a `qml.RY` operator is encountered with an angle of rotation that is less than `0.5`:

python
qml.BooleanFn
def c0(op):
return isinstance(op, qml.RY) and op.parameters[0] < 0.5


Conditions can also be combined together with `&`, `and`, `|`, etc. Once the conditions under which noise is to be inserted have been stated, we can specify exactly what noise is inserted with the following:

* `qml.noise.partial_wires(op)`: insert `op` on the wires that are specified by the condition that triggers adding this noise
* custom noise operations: custom noise can be specified by defining a standard quantum function like below.
python
def n0(op, **kwargs):
qml.RY(op.parameters[0] * 0.05, wires=op.wires)


With that, we can create a `qml.NoiseModel` object whose argument must be a dictionary mapping conditions to noise:

python
c1 = qml.noise.op_eq(qml.X) & qml.noise.wires_in([0, 1])
n1 = qml.noise.partial_wires(qml.AmplitudeDamping, 0.4)

noise_model = qml.NoiseModel({c0: n0, c1: n1})


pycon
>>> noise_model
NoiseModel({ BooleanFn(c0): n0 OpEq(PauliX) | WiresIn([0, 1]): AmplitudeDamping(gamma=0.4) })


The noise model created can then be added to a QNode with `qml.add_noise`:

python
dev = qml.device("lightning.qubit", wires=3)

qml.qnode(dev)
def circuit():
qml.Y(0)
qml.CNOT([0, 1])
qml.RY(0.3, wires=2) triggers c0
qml.X(1) triggers c1
return qml.state()


pycon
>>> print(qml.draw(circuit)())
0: ──Y────────╭●────┤ State
1: ───────────╰X──X─┤ State
2: ──RY(0.30)───────┤ State
>>> circuit = qml.add_noise(circuit, noise_model)
>>> print(qml.draw(circuit)())
0: ──Y────────╭●───────────────────────────────────┤ State
1: ───────────╰X─────────X──AmplitudeDamping(0.40)─┤ State
2: ──RY(0.30)──RY(0.01)────────────────────────────┤ State


If more than one transform is applied to a QNode, control over when/where the `add_noise` transform is applied in relation to the other transforms can be specified with the `level` keyword argument. By default, `add_noise` is applied after all the transforms that have been manually applied to the QNode until that point. To learn more about this new functionality, check out our [noise module documentation](https://docs.pennylane.ai/en/stable/code/qml_noise.html) and keep your eyes peeled for an in-depth demo!

<h4>Catch bugs with the PennyLane debugger 🚫🐞</h4>

* The new PennyLane quantum debugger allows pausing simulation via the `qml.breakpoint()` command and provides tools for analyzing quantum circuits during execution. [(5680)](https://github.com/PennyLaneAI/pennylane/pull/5680) [(#5749)](https://github.com/PennyLaneAI/pennylane/pull/5749) [(#5789)](https://github.com/PennyLaneAI/pennylane/pull/5789)

This includes monitoring the circuit via measurements using `qml.debug_state()`, `qml.debug_probs()`, `qml.debug_expval()`, and `qml.debug_tape()`, stepping through the operations in a quantum circuit, and interactively adding operations during execution.

Including `qml.breakpoint()` in a circuit will cause the simulation to pause during execution and bring up the interactive console. For example, consider the following code in a Python file called `script.py`:

python
qml.qnode(qml.device('default.qubit', wires=(0,1,2)))
def circuit(x):
qml.Hadamard(wires=0)
qml.CNOT(wires=(0,2))
qml.breakpoint()

qml.RX(x, wires=1)
qml.RY(x, wires=2)
qml.breakpoint()

return qml.sample()

circuit(1.2345)


Upon executing `script.py`, the simulation pauses at the first breakpoint:

pycon
> /Users/your/path/to/script.py(8)circuit()
-> qml.RX(x, wires=1)
[pldb]


While debugging, we can access circuit information. For example, `qml.debug_tape()` returns the tape of the circuit, giving access to its operations and drawing:

pycon
[pldb] tape = qml.debug_tape()
[pldb] print(tape.draw(wire_order=[0,1,2]))
0: ──H─╭●─┤
2: ────╰X─┤
[pldb] tape.operations
[Hadamard(wires=[0]), CNOT(wires=[0, 2])]


While `qml.debug_state()` is equivalent to `qml.state()` and gives the current state:

pycon
[pldb] print(qml.debug_state())
[0.70710678+0.j 0. +0.j 0. +0.j 0. +0.j 1. +0.j 0.70710678+0.j 0. +0.j 0. +0.j]


Other debugger functions like `qml.debug_probs()` and `qml.debug_expval()` also function like their simulation counterparts (`qml.probs` and `qml.expval`, respectively) and are described in more detail in the [debugger documentation](https://docs.pennylane.ai/en/stable/code/qml_debugging.html) Additionally, standard debugging commands are available to navigate through code, including `list`, `longlist`, `next`, `continue`, and `quit`, as described in [the debugging documentation](https://docs.pennylane.ai/en/stable/code/qml_debugging.html#controlling-code-execution-in-the-debugging-context). Finally, to modify a circuit mid-run, simply call the desired PennyLane operations:

pycon
[pldb] qml.CNOT(wires=(0,2))
CNOT(wires=[0, 2])
[pldb] print(qml.debug_tape().draw(wire_order=[0,1,2]))
0: ──H─╭●─╭●─┤
2: ────╰X─╰X─┤


Stay tuned for an in-depth demonstration on using this feature with real-world examples! <h4>Convert between OpenFermion and PennyLane 🤝</h4>

* Two new functions called `qml.from_openfermion` and `qml.to_openfermion` are now available to convert between OpenFermion and PennyLane objects. This includes both fermionic and qubit operators. [(5773)](https://github.com/PennyLaneAI/pennylane/pull/5773) [(#5808)](https://github.com/PennyLaneAI/pennylane/pull/5808) [(#5881)](https://github.com/PennyLaneAI/pennylane/pull/5881)

For fermionic operators:

pycon
>>> import openfermion
>>> of_fermionic = openfermion.FermionOperator('0^ 2')
>>> type(of_fermionic)
<class 'openfermion.ops.operators.fermion_operator.FermionOperator'>
>>> pl_fermionic = qml.from_openfermion(of_fermionic)
>>> type(pl_fermionic)
<class 'pennylane.fermi.fermionic.FermiWord'>
>>> print(pl_fermionic)
a⁺(0) a(2)


And for qubit operators:

pycon
>>> of_qubit = 0.5 * openfermion.QubitOperator('X0 X5')
>>> pl_qubit = qml.from_openfermion(of_qubit)
>>> print(pl_qubit)
0.5 * (X(0) X(5))


<h4>Better control over when drawing and specs take place 🎚️</h4>

* It is now possible to control the stage at which `qml.draw`, `qml.draw_mpl`, and `qml.specs` occur within a QNode's [transform](https://docs.pennylane.ai/en/stable/code/qml_transforms.html) program. [(#5855)](https://github.com/PennyLaneAI/pennylane/pull/5855) [(#5781)](https://github.com/PennyLaneAI/pennylane/pull/5781/)

Consider the following circuit which has multiple transforms applied:

python
qml.transforms.split_non_commuting
qml.transforms.cancel_inverses
qml.transforms.merge_rotations
qml.qnode(qml.device("default.qubit"))
def f():
qml.Hadamard(0)
qml.Y(0)
qml.RX(0.4, 0)
qml.RX(-0.4, 0)
qml.Y(0)
return qml.expval(qml.X(0) + 2 * qml.Y(0))


We can specify a `level` value when using `qml.draw()`:

pycon
>>> print(qml.draw(f, level=0)()) input program
0: ──H──Y──RX(0.40)──RX(-0.40)──Y─┤ <X+(2.00*Y)>
>>> print(qml.draw(f, level=1)()) rotations merged
0: ──H──Y──Y─┤ <X+(2.00*Y)>
>>> print(qml.draw(f, level=2)()) inverses cancelled
0: ──H─┤ <X+(2.00*Y)>
>>> print(qml.draw(f, level=3)()) Hamiltonian expanded
0: ──H─┤ <X>

0: ──H─┤ <Y>


The [qml.workflow.get_transform_program function](https://docs.pennylane.ai/en/latest/code/api/pennylane.workflow.get_transform_program.html) can be used to see the full transform program.

pycon
>>> qml.workflow.get_transform_program(f)
TransformProgram(merge_rotations, cancel_inverses, split_non_commuting, validate_device_wires, mid_circuit_measurements, decompose, validate_measurements, validate_observables, no_sampling)


Note that additional transforms can be added automatically from device preprocessing or gradient calculations. Rather than providing an integer value to `level`, it is possible to target the `"user"`, `"gradient"` or `"device"` stages:

python
n_wires = 3
x = np.random.random((2, n_wires))

qml.qnode(qml.device("default.qubit"))
def f():
qml.BasicEntanglerLayers(x, range(n_wires))
return qml.expval(qml.X(0))


pycon
>>> print(qml.draw(f, level="device")())
0: ──RX(0.28)─╭●────╭X──RX(0.70)─╭●────╭X─┤ <X>
1: ──RX(0.52)─╰X─╭●─│───RX(0.65)─╰X─╭●─│──┤
2: ──RX(0.00)────╰X─╰●──RX(0.03)────╰X─╰●─┤


<h3>Improvements 🛠</h3>

<h4>Community contributions, including UnitaryHACK 💛</h4>

* `default.clifford` now supports arbitrary state-based measurements with `qml.Snapshot`. [(5794)](https://github.com/PennyLaneAI/pennylane/pull/5794)

* `qml.equal` now properly handles `Pow`, `Adjoint`, `Exp`, and `SProd` operators as arguments across different interfaces and tolerances with the addition of four new keyword arguments: `check_interface`, `check_trainability`, `atol` and `rtol`. [(5668)](https://github.com/PennyLaneAI/pennylane/pull/5668)

* The implementation for `qml.assert_equal` has been updated for `Operator`, `Controlled`, `Adjoint`, `Pow`, `Exp`, `SProd`, `ControlledSequence`, `Prod`, `Sum`, `Tensor` and `Hamiltonian` instances. [(5780)](https://github.com/PennyLaneAI/pennylane/pull/5780) [(#5877)](https://github.com/PennyLaneAI/pennylane/pull/5877)

* `qml.from_qasm` now supports the ability to convert mid-circuit measurements from `OpenQASM 2` code, and it can now also take an optional argument to specify a list of measurements to be performed at the end of the circuit, just like `qml.from_qiskit`. [(5818)](https://github.com/PennyLaneAI/pennylane/pull/5818)

* Four new operators have been added for simulating noise on the `default.qutrit.mixed` device: [(5502)](https://github.com/PennyLaneAI/pennylane/pull/5502) [(#5793)](https://github.com/PennyLaneAI/pennylane/issues/5793) [(#5503)](https://github.com/PennyLaneAI/pennylane/pull/5503) [(#5757)](https://github.com/PennyLaneAI/pennylane/pull/5757) [(#5799)](https://github.com/PennyLaneAI/pennylane/pull/5799) [(#5784)](https://github.com/PennyLaneAI/pennylane/pull/5784)

* `qml.QutritDepolarizingChannel`: a channel that adds depolarizing noise.
* `qml.QutritChannel`: enables the specification of noise using a collection of (3x3) Kraus matrices.
* `qml.QutritAmplitudeDamping`: a channel that adds noise processes modelled by amplitude damping.
* `qml.TritFlip`: a channel that adds trit flip errors, such as misclassification.

<h4>Faster and more flexible mid-circuit measurements</h4>

* The `default.qubit` device supports a depth-first tree-traversal algorithm to accelerate native mid-circuit measurement execution. Accessible through the QNode argument `mcm_method="tree-traversal"`, this new implementation supports classical control, collecting statistics, and post-selection, along with all measurements enabled with `qml.dynamic_one_shot`. More information about this new mid-circuit measurement method can be found on our [measurement documentation page](https://docs.pennylane.ai/en/stable/introduction/dynamic_quantum_circuits.html#tree-traversal-algorithm). [(5180)](https://github.com/PennyLaneAI/pennylane/pull/5180)

* `qml.QNode` and the `qml.qnode` decorator now accept two new keyword arguments: `postselect_mode` and `mcm_method`. These keyword arguments can be used to configure how the device should behave when running circuits with mid-circuit measurements. [(5679)](https://github.com/PennyLaneAI/pennylane/pull/5679) [(#5833)](https://github.com/PennyLaneAI/pennylane/pull/5833) [(#5850)](https://github.com/PennyLaneAI/pennylane/pull/5850)

* `postselect_mode="hw-like"` indicates to devices to discard invalid shots when postselecting mid-circuit measurements. Use `postselect_mode="fill-shots"` to unconditionally sample the postselected value, thus making all samples valid. This is equivalent to sampling until the number of valid samples matches the total number of shots.
* `mcm_method` will indicate which strategy to use for running circuits with mid-circuit measurements. Use `mcm_method="deferred"` to use the deferred measurements principle, or `mcm_method="one-shot"` to execute once for each shot. If `qml.qjit` is being used (the Catalyst compiler), `mcm_method="single-branch-statistics"` is also available. Using this method, a single branch of the execution tree will be randomly explored.

* The `dynamic_one_shot` transform received a few improvements:
* `dynamic_one_shot` is now compatible with `qml.qjit` (the Catalyst compiler). [(5766)](https://github.com/PennyLaneAI/pennylane/pull/5766) [(#5888)](https://github.com/PennyLaneAI/pennylane/pull/5888)
* `dynamic_one_shot` now uses a single auxiliary tape with a shot vector and `default.qubit` implements the loop over shots with `jax.vmap`. [(5617)](https://github.com/PennyLaneAI/pennylane/pull/5617)
* `dynamic_one_shot` is now compatible with `jax.jit`. [(5557)](https://github.com/PennyLaneAI/pennylane/pull/5557)

* When using `defer_measurements` with postselection, operations that will never be active due to the postselected state are skipped in the transformed quantum circuit. In addition, postselected controls are skipped, as they are evaluated when the transform is applied. This optimization feature can be turned off by setting `reduce_postselected=False`. [(5558)](https://github.com/PennyLaneAI/pennylane/pull/5558)

Consider a simple circuit with three mid-circuit measurements, two of which are postselecting, and a single gate conditioned on those measurements:

python
qml.qnode(qml.device("default.qubit"))
def node(x):
qml.RX(x, 0)
qml.RX(x, 1)
qml.RX(x, 2)
mcm0 = qml.measure(0, postselect=0, reset=False)
mcm1 = qml.measure(1, postselect=None, reset=True)
mcm2 = qml.measure(2, postselect=1, reset=False)
qml.cond(mcm0 + mcm1 + mcm2 == 1, qml.RX)(0.5, 3)
return qml.expval(qml.Z(0) qml.Z(3))


Without the new optimization, we obtain three gates, each controlled on the three measured qubits. They correspond to the combinations of controls that satisfy the condition `mcm0 + mcm1 + mcm2 == 1`:

pycon
>>> print(qml.draw(qml.defer_measurements(node, reduce_postselected=False))(0.6))
0: ──RX(0.60)──|0⟩⟨0|─╭●─────────────────────────────────────────────┤ ╭<ZZ>
1: ──RX(0.60)─────────│──╭●─╭X───────────────────────────────────────┤ │
2: ──RX(0.60)─────────│──│──│───|1⟩⟨1|─╭○────────╭○────────╭●────────┤ │
3: ───────────────────│──│──│──────────├RX(0.50)─├RX(0.50)─├RX(0.50)─┤ ╰<ZZ>
4: ───────────────────╰X─│──│──────────├○────────├●────────├○────────┤
5: ──────────────────────╰X─╰●─────────╰●────────╰○────────╰○────────┤


If we do not explicitly deactivate the optimization, we obtain a much simpler circuit:

pycon
>>> print(qml.draw(qml.defer_measurements(node))(0.6))
0: ──RX(0.60)──|0⟩⟨0|─╭●─────────────────┤ ╭<ZZ>
1: ──RX(0.60)─────────│──╭●─╭X───────────┤ │
2: ──RX(0.60)─────────│──│──│───|1⟩⟨1|───┤ │
3: ───────────────────│──│──│──╭RX(0.50)─┤ ╰<ZZ>
4: ───────────────────╰X─│──│──│─────────┤
5: ──────────────────────╰X─╰●─╰○────────┤


There is only one controlled gate with only one control wire.

* Mid-circuit measurement tests have been streamlined and refactored, removing most end-to-end tests from the native MCM test file, but keeping one that validates multiple mid-circuit measurements with any allowed return and interface end-to-end tests. [(5787)](https://github.com/PennyLaneAI/pennylane/pull/5787)

<h4>Access to QROM</h4>

* [The QROM algorithm](https://arxiv.org/abs/1812.00954) is now available in PennyLane with `qml.QROM`. This template allows you to enter classical data in the form of bitstrings. [(#5688)](https://github.com/PennyLaneAI/pennylane/pull/5688)

python
bitstrings = ["010", "111", "110", "000"]

dev = qml.device("default.qubit", shots = 1)

qml.qnode(dev)
def circuit():
qml.BasisEmbedding(2, wires = [0,1])

qml.QROM(bitstrings = bitstrings, control_wires = [0,1], target_wires = [2,3,4], work_wires = [5,6,7])

return qml.sample(wires = [2,3,4])

pycon
>>> print(circuit())
[1 1 0]


<h4>Capturing and representing hybrid programs</h4>

* A number of templates have been updated to be valid PyTrees and PennyLane operations. [(5698)](https://github.com/PennyLaneAI/pennylane/pull/5698)

* PennyLane operators, measurements, and QNodes can now automatically be captured as instructions in JAXPR. [(5564)](https://github.com/PennyLaneAI/pennylane/pull/5564) [(#5511)](https://github.com/PennyLaneAI/pennylane/pull/5511) [(#5708)](https://github.com/PennyLaneAI/pennylane/pull/5708) [(#5523)](https://github.com/PennyLaneAI/pennylane/pull/5523) [(#5686)](https://github.com/PennyLaneAI/pennylane/pull/5686) [(#5889)](https://github.com/PennyLaneAI/pennylane/pull/5889)

* The `qml.PyTrees` module now has `flatten` and `unflatten` methods for serializing PyTrees. [(5701)](https://github.com/PennyLaneAI/pennylane/pull/5701)

* `qml.sample` can now be used on Boolean values representing mid-circuit measurement results in traced quantum functions. This feature is used with Catalyst to enable the pattern `m = measure(0); qml.sample(m)`. [(5673)](https://github.com/PennyLaneAI/pennylane/pull/5673)

<h4>Quantum chemistry</h4>

* The `qml.qchem.Molecule` object received a few improvements:
* `qml.qchem.Molecule` is now the central object used by all qchem functions. [(5571)](https://github.com/PennyLaneAI/pennylane/pull/5571)
* `qml.qchem.Molecule` now supports Angstrom as a unit. [(5694)](https://github.com/PennyLaneAI/pennylane/pull/5694)
* `qml.qchem.Molecule` now supports open-shell systems. [(5655)](https://github.com/PennyLaneAI/pennylane/pull/5655)

* The `qml.qchem.molecular_hamiltonian` function now supports parity and Bravyi-Kitaev mappings. [(5657)](https://github.com/PennyLaneAI/pennylane/pull/5657/)

* `qml.qchem.molecular_dipole` function has been added for calculating the dipole operator using the `"dhf"` and `"openfermion"` backends. [(5764)](https://github.com/PennyLaneAI/pennylane/pull/5764)

* The qchem module now has dedicated functions for calling the `pyscf` and `openfermion` backends and the `molecular_hamiltonian` and `molecular_dipole` functions have been moved to `hamiltonian` and `dipole` modules. [(5553)](https://github.com/PennyLaneAI/pennylane/pull/5553) [(#5863)](https://github.com/PennyLaneAI/pennylane/pull/5863)

* More fermionic-to-qubit tests have been added to cover cases when the mapped operator is different for various mapping schemes. [(5873)](https://github.com/PennyLaneAI/pennylane/pull/5873)

<h4>Easier development</h4>

* Logging now allows for an easier opt-in across the stack and support has been extended to Catalyst. [(5528)](https://github.com/PennyLaneAI/pennylane/pull/5528)

* Three new Pytest markers have been added for easier management of our test suite: `unit`, `integration` and `system`. [(5517)](https://github.com/PennyLaneAI/pennylane/pull/5517)

<h4>Other improvements</h4>

* `qml.MultiControlledX` can now be decomposed even when no `work_wires` are provided. The implementation returns $\mathcal{O}(\mbox{len(control wires)}^2)$ operations and is applicable for any multi-controlled unitary gate. This decomposition is provided in [arXiv:quant-ph/9503016](https://arxiv.org/abs/quant-ph/9503016). [(#5735)](https://github.com/PennyLaneAI/pennylane/pull/5735)

* A new function called `expectation_value` has been added to `qml.math` to calculate the expectation value of a matrix for pure states. [(4484)](https://github.com/PennyLaneAI/pennylane/pull/4484)

pycon
>>> state_vector = [1/np.sqrt(2), 0, 1/np.sqrt(2), 0]
>>> operator_matrix = qml.matrix(qml.PauliZ(0), wire_order=[0,1])
>>> qml.math.expectation_value(operator_matrix, state_vector)
tensor(-2.23711432e-17+0.j, requires_grad=True)


* `param_shift` with the `broadcast=True` option now supports shot vectors and multiple measurements. [(5667)](https://github.com/PennyLaneAI/pennylane/pull/5667)

* `qml.TrotterProduct` is now compatible with resource tracking by inheriting from `ResourcesOperation`. [(5680)](https://github.com/PennyLaneAI/pennylane/pull/5680)

* `packaging` is now a required package in PennyLane. [(5769)](https://github.com/PennyLaneAI/pennylane/pull/5769)

* `qml.ctrl` now works with tuple-valued `control_values` when applied to any already controlled operation. [(5725)](https://github.com/PennyLaneAI/pennylane/pull/5725)

* The sorting order of parameter-shift terms is now guaranteed to resolve ties in the absolute value with the sign of the shifts. [(5582)](https://github.com/PennyLaneAI/pennylane/pull/5582)

* `qml.transforms.split_non_commuting` can now handle circuits containing measurements of multi-term observables. [(5729)](https://github.com/PennyLaneAI/pennylane/pull/5729) [(#5838)](https://github.com/PennyLaneAI/pennylane/pull/5838) [(#5828)](https://github.com/PennyLaneAI/pennylane/pull/5828) [(#5869)](https://github.com/PennyLaneAI/pennylane/pull/5869) [(#5939)](https://github.com/PennyLaneAI/pennylane/pull/5939) [(#5945)](https://github.com/PennyLaneAI/pennylane/pull/5945)

* `qml.devices.LegacyDevice` is now an alias for `qml.Device`, so it is easier to distinguish it from `qml.devices.Device`, which follows the new device API. [(5581)](https://github.com/PennyLaneAI/pennylane/pull/5581)

* The `dtype` for `eigvals` of `X`, `Y`, `Z` and `Hadamard` is changed from `int` to `float`, making them consistent with the other observables. The `dtype` of the returned values when sampling these observables (e.g. `qml.sample(X(0))`) is also changed to `float`. [(5607)](https://github.com/PennyLaneAI/pennylane/pull/5607)

* The framework for the development of an `assert_equal` function for testing operator comparison has been set up. [(5634)](https://github.com/PennyLaneAI/pennylane/pull/5634) [(#5858)](https://github.com/PennyLaneAI/pennylane/pull/5858)

* The `decompose` transform has an `error` keyword argument to specify the type of error that should be raised, allowing error types to be more consistent with the context the `decompose` function is used in. [(5669)](https://github.com/PennyLaneAI/pennylane/pull/5669)

* Empty initialization of `PauliVSpace` is permitted. [(5675)](https://github.com/PennyLaneAI/pennylane/pull/5675)

* `qml.tape.QuantumScript` properties are only calculated when needed, instead of on initialization. This decreases the classical overhead by over 20%. Also, `par_info`, `obs_sharing_wires`, and `obs_sharing_wires_id` are now public attributes. [(5696)](https://github.com/PennyLaneAI/pennylane/pull/5696)

* The `qml.data` module now supports PyTree data types as dataset attributes [(5732)](https://github.com/PennyLaneAI/pennylane/pull/5732)

* `qml.ops.Conditional` now inherits from `qml.ops.SymbolicOp`, thus it inherits several useful common functionalities. Other properties such as adjoint and diagonalizing gates have been added using the `base` properties. [(5772)](https://github.com/PennyLaneAI/pennylane/pull/5772)

* New dispatches for `qml.ops.Conditional` and `qml.MeasurementValue` have been added to `qml.equal`. [(5772)](https://github.com/PennyLaneAI/pennylane/pull/5772)

* The `qml.snapshots` transform now supports arbitrary devices by running a separate tape for each snapshot for unsupported devices. [(5805)](https://github.com/PennyLaneAI/pennylane/pull/5805)

* The `qml.Snapshot` operator now accepts sample-based measurements for finite-shot devices. [(5805)](https://github.com/PennyLaneAI/pennylane/pull/5805)

* Device preprocess transforms now happen inside the ML boundary. [(5791)](https://github.com/PennyLaneAI/pennylane/pull/5791)

* Transforms applied to callables now use `functools.wraps` to preserve the docstring and call signature of the original function. [(5857)](https://github.com/PennyLaneAI/pennylane/pull/5857)

* `qml.qsvt()` now supports JAX arrays with angle conversions. [(5853)](https://github.com/PennyLaneAI/pennylane/pull/5853)

* The sorting order of parameter-shift terms is now guaranteed to resolve ties in the absolute value with the sign of the shifts. [(5583)](https://github.com/PennyLaneAI/pennylane/pull/5583)

<h3>Breaking changes 💔</h3>

* Passing `shots` as a keyword argument to a `QNode` initialization now raises an error instead of ignoring the input. [(5748)](https://github.com/PennyLaneAI/pennylane/pull/5748)

* A custom decomposition can no longer be provided to `qml.QDrift`. Instead, apply the operations in your custom operation directly with `qml.apply`. [(5698)](https://github.com/PennyLaneAI/pennylane/pull/5698)

* Sampling observables composed of `X`, `Y`, `Z` and `Hadamard` now returns values of type `float` instead of `int`. [(5607)](https://github.com/PennyLaneAI/pennylane/pull/5607)

* `qml.is_commuting` no longer accepts the `wire_map` argument, which does not bring any functionality. [(5660)](https://github.com/PennyLaneAI/pennylane/pull/5660)

* `qml.from_qasm_file` has been removed. The user can open files and load their content using `qml.from_qasm`. [(5659)](https://github.com/PennyLaneAI/pennylane/pull/5659)

* `qml.load` has been removed in favour of more specific functions, such as `qml.from_qiskit`, etc. [(5654)](https://github.com/PennyLaneAI/pennylane/pull/5654)

* `qml.transforms.convert_to_numpy_parameters` is now a proper transform and its output signature has changed, returning a list of `QuantumScript`s and a post-processing function instead of simply the transformed circuit. [(5693)](https://github.com/PennyLaneAI/pennylane/pull/5693)

* `Controlled.wires` does not include `self.work_wires` anymore. That can be accessed separately through `Controlled.work_wires`. Consequently, `Controlled.active_wires` has been removed in favour of the more common `Controlled.wires`. [(5728)](https://github.com/PennyLaneAI/pennylane/pull/5728)

<h3>Deprecations 👋</h3>

* The `simplify` argument in `qml.Hamiltonian` and `qml.ops.LinearCombination` has been deprecated. Instead, `qml.simplify()` can be called on the constructed operator. [(5677)](https://github.com/PennyLaneAI/pennylane/pull/5677)

* `qml.transforms.map_batch_transform` has been deprecated, since a transform can be applied directly to a batch of tapes. [(5676)](https://github.com/PennyLaneAI/pennylane/pull/5676)

* The default behaviour of `qml.from_qasm()` to remove measurements in the QASM code has been deprecated. Use `measurements=[]` to keep this behaviour or `measurements=None` to keep the measurements from the QASM code. [(5882)](https://github.com/PennyLaneAI/pennylane/pull/5882) [(#5904)](https://github.com/PennyLaneAI/pennylane/pull/5904)

<h3>Documentation 📝</h3>

* The `qml.qchem` docs have been updated to showcase the new improvements. [(5758)](https://github.com/PennyLaneAI/pennylane/pull/5758/) [(#5638)](https://github.com/PennyLaneAI/pennylane/pull/5638/)

* Several links to other functions in measurement process docstrings have been fixed. [(5913)](https://github.com/PennyLaneAI/pennylane/pull/5913)

* Information about mid-circuit measurements has been moved from the measurements quickstart page to its own [mid-circuit measurements quickstart page](https://docs.pennylane.ai/en/stable/introduction/mid_circuit_measurements.html) [(#5870)](https://github.com/PennyLaneAI/pennylane/pull/5870)

* The documentation for the `default.tensor` device has been added. [(5719)](https://github.com/PennyLaneAI/pennylane/pull/5719)

* A small typo was fixed in the docstring for `qml.sample`. [(5685)](https://github.com/PennyLaneAI/pennylane/pull/5685)

* Typesetting for some of the documentation was fixed, (use of left/right delimiters, fractions, and fixing incorrectly set up commands) [(5804)](https://github.com/PennyLaneAI/pennylane/pull/5804)

* The `qml.Tracker` examples have been updated. [(5803)](https://github.com/PennyLaneAI/pennylane/pull/5803)

* The input types for `coupling_map` in `qml.transpile` have been updated to reflect all the allowed input types by `nx.to_networkx_graph`. [(5864)](https://github.com/PennyLaneAI/pennylane/pull/5864)

* The text in the `qml.data` module and datasets quickstart has been slightly modified to lead to the quickstart first and highlight `list_datasets`. [(5484)](https://github.com/PennyLaneAI/pennylane/pull/5484)

<h3>Bug fixes 🐛</h3>

* `qml.compiler.active` first checks whether Catalyst is imported at all to avoid changing `jax_enable_x64` on module initialization. [(5960)](https://github.com/PennyLaneAI/pennylane/pull/5960)

* The `__invert__` dunder method of the `MeasurementValue` class uses an array-valued function. [(5955)](https://github.com/PennyLaneAI/pennylane/pull/5955)

* Skip `Projector`-measurement tests on devices that do not support it. [(5951)](https://github.com/PennyLaneAI/pennylane/pull/5951)

* The `default.tensor` device now preserves the order of wires if the initial MPS is created from a dense state vector. [(5892)](https://github.com/PennyLaneAI/pennylane/pull/5892)

* Fixed a bug where `hadamard_grad` returned a wrong shape for `qml.probs()` without wires. [(5860)](https://github.com/PennyLaneAI/pennylane/pull/5860)

* An error is now raised on processing an `AnnotatedQueue` into a `QuantumScript` if the queue contains something other than an `Operator`, `MeasurementProcess`, or `QuantumScript`. [(5866)](https://github.com/PennyLaneAI/pennylane/pull/5866)

* Fixed a bug in the wire handling on special controlled ops. [(5856)](https://github.com/PennyLaneAI/pennylane/pull/5856)

* Fixed a bug where `Sum`'s with repeated identical operations ended up with the same hash as `Sum`'s with different numbers of repeats. [(5851)](https://github.com/PennyLaneAI/pennylane/pull/5851)

* `qml.qaoa.cost_layer` and `qml.qaoa.mixer_layer` can now be used with `Sum` operators. [(5846)](https://github.com/PennyLaneAI/pennylane/pull/5846)

* Fixed a bug where `qml.MottonenStatePreparation` produces wrong derivatives at special parameter values. [(5774)](https://github.com/PennyLaneAI/pennylane/pull/5774)

* Fixed a bug where fractional powers and adjoints of operators were commuted, which is not well-defined/correct in general. Adjoints of fractional powers can no longer be evaluated. [(5835)](https://github.com/PennyLaneAI/pennylane/pull/5835)

* `qml.qnn.TorchLayer` now works with tuple returns. [(5816)](https://github.com/PennyLaneAI/pennylane/pull/5816)

* An error is now raised if a transform is applied to a catalyst qjit object. [(5826)](https://github.com/PennyLaneAI/pennylane/pull/5826)

* `qml.qnn.KerasLayer` and `qml.qnn.TorchLayer` no longer mutate the input `qml.QNode`'s interface. [(5800)](https://github.com/PennyLaneAI/pennylane/pull/5800)

* Docker builds on PR merging has been disabled. [(5777)](https://github.com/PennyLaneAI/pennylane/pull/5777)

* The validation of the adjoint method in `DefaultQubit` correctly handles device wires now. [(5761)](https://github.com/PennyLaneAI/pennylane/pull/5761)

* `QuantumPhaseEstimation.map_wires` on longer modifies the original operation instance. [(5698)](https://github.com/PennyLaneAI/pennylane/pull/5698)

* The decomposition of `qml.AmplitudeAmplification` now correctly queues all operations. [(5698)](https://github.com/PennyLaneAI/pennylane/pull/5698)

* Replaced `semantic_version` with `packaging.version.Version`, since the former cannot handle the metadata `.post` in the version string. [(5754)](https://github.com/PennyLaneAI/pennylane/pull/5754)

* The `dynamic_one_shot` transform now has expanded support for the `jax` and `torch` interfaces. [(5672)](https://github.com/PennyLaneAI/pennylane/pull/5672)

* The decomposition of `StronglyEntanglingLayers` is now compatible with broadcasting. [(5716)](https://github.com/PennyLaneAI/pennylane/pull/5716)

* `qml.cond` can now be applied to `ControlledOp` operations when deferring measurements. [(5725)](https://github.com/PennyLaneAI/pennylane/pull/5725)

* The legacy `Tensor` class can now handle a `Projector` with abstract tracer input. [(5720)](https://github.com/PennyLaneAI/pennylane/pull/5720)

* Fixed a bug that raised an error regarding expected versus actual `dtype` when using `JAX-JIT` on a circuit that returned samples of observables containing the `qml.Identity` operator. [(5607)](https://github.com/PennyLaneAI/pennylane/pull/5607)

* The signature of `CaptureMeta` objects (like `Operator`) now match the signature of the `__init__` call. [(5727)](https://github.com/PennyLaneAI/pennylane/pull/5727)

* Vanilla NumPy arrays are now used in `test_projector_expectation` to avoid differentiating `qml.Projector` with respect to the state attribute. [(5683)](https://github.com/PennyLaneAI/pennylane/pull/5683)

* `qml.Projector` is now compatible with `jax.jit`. [(5595)](https://github.com/PennyLaneAI/pennylane/pull/5595)

* Finite-shot circuits with a `qml.probs` measurement, both with a `wires` or `op` argument, can now be compiled with `jax.jit`. [(5619)](https://github.com/PennyLaneAI/pennylane/pull/5619)

* `param_shift`, `finite_diff`, `compile`, `insert`, `merge_rotations`, and `transpile` now all work with circuits with non-commuting measurements. [(5424)](https://github.com/PennyLaneAI/pennylane/pull/5424) [(#5681)](https://github.com/PennyLaneAI/pennylane/pull/5681)

* A correction has been added to `qml.bravyi_kitaev` to call the correct function for a `qml.FermiSentence` input. [(5671)](https://github.com/PennyLaneAI/pennylane/pull/5671)

* Fixed a bug where `sum_expand` produces incorrect result dimensions when combined with shot vectors, multiple measurements, and parameter broadcasting. [(5702)](https://github.com/PennyLaneAI/pennylane/pull/5702)

* Fixed a bug in `qml.math.dot` that raises an error when only one of the operands is a scalar. [(5702)](https://github.com/PennyLaneAI/pennylane/pull/5702)

* `qml.matrix` is now compatible with QNodes compiled by `qml.qjit`. [(5753)](https://github.com/PennyLaneAI/pennylane/pull/5753)

* `qml.snapshots` raises an error when a measurement other than `qml.state` is requested from `default.qubit.legacy` instead of silently returning the statevector. [(5805)](https://github.com/PennyLaneAI/pennylane/pull/5805)

* Fixed a bug where `default.qutrit` was falsely determined to be natively compatible with `qml.snapshots`. [(5805)](https://github.com/PennyLaneAI/pennylane/pull/5805)

* Fixed a bug where the measurement of a `qml.Snapshot` instance was not passed on during the `qml.adjoint` and `qml.ctrl` operations. [(5805)](https://github.com/PennyLaneAI/pennylane/pull/5805)

* `qml.CNOT` and `qml.Toffoli` now have an `arithmetic_depth` of `1`, as they are controlled operations. [(5797)](https://github.com/PennyLaneAI/pennylane/pull/5797)

* Fixed a bug where the gradient of `ControlledSequence`, `Reflection`, `AmplitudeAmplification`, and `Qubitization` was incorrect on `default.qubit.legacy` with `parameter_shift`. [(5806)](https://github.com/PennyLaneAI/pennylane/pull/5806)

* Fixed a bug where `split_non_commuting` raises an error when the circuit contains measurements of observables that are not Pauli words. [(5827)](https://github.com/PennyLaneAI/pennylane/pull/5827)

* The `simplify` method for `qml.Exp` now returns an operator with the correct number of Trotter steps, i.e. equal to the one from the pre-simplified operator. [(5831)](https://github.com/PennyLaneAI/pennylane/pull/5831)

* Fixed a bug where `CompositeOp.overlapping_ops` would put overlapping operators in different groups, leading to incorrect results returned by `LinearCombination.eigvals()`. [(5847)](https://github.com/PennyLaneAI/pennylane/pull/5847)

* The correct decomposition for a `qml.PauliRot` with an identity as `pauli_word` has been implemented, i.e. returns a `qml.GlobalPhase` with half the angle. [(5875)](https://github.com/PennyLaneAI/pennylane/pull/5875)

* `qml.pauli_decompose` now works in a jit-ted context, such as `jax.jit` and `qml.qjit`. [(5878)](https://github.com/PennyLaneAI/pennylane/pull/5878)

<h3>Contributors ✍️</h3>

This release contains contributions from (in alphabetical order):

Tarun Kumar Allamsetty, Guillermo Alonso-Linaje, Utkarsh Azad, Lillian M. A. Frederiksen, Ludmila Botelho, Gabriel Bottrill, Thomas Bromley, Jack Brown, Astral Cai, Ahmed Darwish, Isaac De Vlugt, Diksha Dhawan, Pietropaolo Frisoni, Emiliano Godinez, Diego Guala, Daria Van Hende, Austin Huang, David Ittah, Soran Jahangiri, Rohan Jain, Mashhood Khan, Korbinian Kottmann, Christina Lee, Vincent Michaud-Rioux, Lee James O'Riordan, Mudit Pandey, Kenya Sakka, Jay Soni, Kazuki Tsuoka, Haochen Paul Wang, David Wierichs.

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

<h4>Estimate errors in a quantum circuit 🧮</h4>

* This version of PennyLane lays the foundation for estimating the total error in a quantum circuit from the combination of individual gate errors. [(5154)](https://github.com/PennyLaneAI/pennylane/pull/5154) [(#5464)](https://github.com/PennyLaneAI/pennylane/pull/5464) [(#5465)](https://github.com/PennyLaneAI/pennylane/pull/5465) [(#5278)](https://github.com/PennyLaneAI/pennylane/pull/5278) [(#5384)](https://github.com/PennyLaneAI/pennylane/pull/5384)

Two new user-facing classes enable calculating and propagating gate errors in PennyLane:

* `qml.resource.SpectralNormError`: the spectral norm error is defined as the distance, in [spectral norm](https://en.wikipedia.org/wiki/Matrix_norm), between the true unitary we intend to apply and the approximate unitary that is actually applied.

* `qml.resource.ErrorOperation`: a base class that inherits from `qml.operation.Operation` and represents quantum operations which carry some form of algorithmic error.

`SpectralNormError` can be used for back-of-the-envelope type calculations like obtaining the spectral norm error between two unitaries via `get_error`:

python
import pennylane as qml
from pennylane.resource import ErrorOperation, SpectralNormError

intended_op = qml.RY(0.40, 0)
actual_op = qml.RY(0.41, 0) angle of rotation is slightly off

pycon
>>> SpectralNormError.get_error(intended_op, actual_op)
0.004999994791668309


`SpectralNormError` is also a key tool to specify errors in larger quantum circuits:

* For operations representing a major building block of an algorithm, we can create a custom operation that inherits from `ErrorOperation`. This child class must override the `error` method and should return a `SpectralNormError` instance:

python
class MyErrorOperation(ErrorOperation):

def __init__(self, error_val, wires):
self.error_val = error_val
super().__init__(wires=wires)

def error(self):
return SpectralNormError(self.error_val)


In this toy example, `MyErrorOperation` introduces an arbitrary `SpectralNormError` when called in a QNode. It does not require a decomposition or matrix representation when used with `null.qubit` (suggested for use with resource and error estimation since circuit executions are not required to calculate resources or errors).

python
dev = qml.device("null.qubit")

qml.qnode(dev)
def circuit():
MyErrorOperation(0.1, wires=0)
MyErrorOperation(0.2, wires=1)
return qml.state()


The total spectral norm error of the circuit can be calculated using `qml.specs`:

pycon
>>> qml.specs(circuit)()['errors']
{'SpectralNormError': SpectralNormError(0.30000000000000004)}


* PennyLane already includes a number of built-in building blocks for algorithms like `QuantumPhaseEstimation` and `TrotterProduct`. `TrotterProduct` now propagates errors based on the number of steps performed in the Trotter product. `QuantumPhaseEstimation` now propagates errors based on the error of its input unitary.

python
dev = qml.device('null.qubit')
hamiltonian = qml.dot([1.0, 0.5, -0.25], [qml.X(0), qml.Y(0), qml.Z(0)])

qml.qnode(dev)
def circuit():
qml.TrotterProduct(hamiltonian, time=0.1, order=2)
qml.QuantumPhaseEstimation(MyErrorOperation(0.01, wires=0), estimation_wires=[1, 2, 3])
return qml.state()


Again, the total spectral norm error of the circuit can be calculated using `qml.specs`:

pycon
>>> qml.specs(circuit)()["errors"]
{'SpectralNormError': SpectralNormError(0.07616666666666666)}


Check out our [error propagation demo](https://pennylane.ai/qml/demos/tutorial_error_prop/) to see how to use these new features in a real-world example!

<h4>Access an extended arsenal of quantum algorithms 🏹</h4>

* The Fast Approximate BLock-Encodings (FABLE) algorithm for embedding a matrix into a quantum circuit as outlined in [arXiv:2205.00081](https://arxiv.org/abs/2205.00081) is now accessible via the `qml.FABLE` template. [(#5107)](https://github.com/PennyLaneAI/pennylane/pull/5107)

The usage of `qml.FABLE` is similar to `qml.BlockEncode` but provides a more efficient circuit construction at the cost of a user-defined approximation level, `tol`. The number of wires that `qml.FABLE` operates on is `2*n + 1`, where `n` defines the dimension of the $2^n \times 2^n$ matrix that we want to block-encode.

python
import numpy as np

A = np.array([[0.1, 0.2], [0.3, 0.4]])
dev = qml.device('default.qubit', wires=3)

qml.qnode(dev)
def circuit():
qml.FABLE(A, tol = 0.001, wires=range(3))
return qml.state()


pycon
>>> mat = qml.matrix(circuit)()
>>> 2 * mat[0:2, 0:2]
array([[0.1+0.j, 0.2+0.j], [0.3+0.j, 0.4+0.j]])


* A high-level interface for amplitude amplification and its variants is now available via the new `qml.AmplitudeAmplification` template. [(5160)](https://github.com/PennyLaneAI/pennylane/pull/5160)

Based on [arXiv:quant-ph/0005055](https://arxiv.org/abs/quant-ph/0005055), given a state $\vert \Psi \rangle = \alpha \vert \phi \rangle + \beta \vert \phi^{\perp} \rangle$, `qml.AmplitudeAmplification` amplifies the amplitude of $\vert \phi \rangle$.

Here's an example with a target state $\vert \phi \rangle = \vert 2 \rangle = \vert 010 \rangle$, an input state $\vert \Psi \rangle = H^{\otimes 3} \vert 000 \rangle$, as well as an oracle that flips the sign of $\vert \phi \rangle$ and does nothing to $\vert \phi^{\perp} \rangle$, which can be achieved in this case through `qml.FlipSign`.

python
qml.prod
def generator(wires):
for wire in wires:
qml.Hadamard(wires=wire)

U = generator(wires=range(3))
O = qml.FlipSign(2, wires=range(3))


Here, `U` is a quantum operation that is created by decorating a quantum function with `qml.prod`. This could alternatively be done by creating a user-defined [custom operation](https://docs.pennylane.ai/en/stable/development/adding_operators.html) with a decomposition. Amplitude amplification can then be set up within a circuit:

python
dev = qml.device("default.qubit")

qml.qnode(dev)
def circuit():
generator(wires=range(3)) prepares |Psi> = U|0>
qml.AmplitudeAmplification(U, O, iters=10)
return qml.probs(wires=range(3))


pycon
>>> print(np.round(circuit(), 3))
[0.01 0.01 0.931 0.01 0.01 0.01 0.01 0.01 ]


As expected, we amplify the $\vert 2 \rangle$ state.

* Reflecting about a given quantum state is now available via `qml.Reflection`. This operation is very useful in the amplitude amplification algorithm and offers a generalization of `qml.FlipSign`, which operates on basis states. [(5159)](https://github.com/PennyLaneAI/pennylane/pull/5159)

`qml.Reflection` works by providing an operation, $U$, that *prepares* the desired state, $\vert \psi \rangle$, that we want to reflect about. In other words, $U$ is such that $U \vert 0 \rangle = \vert \psi \rangle$. In PennyLane, $U$ must be an `Operator`. For example, if we want to reflect about $\vert \psi \rangle = \vert + \rangle$, then $U = H$:

python
U = qml.Hadamard(wires=0)
dev = qml.device('default.qubit')

qml.qnode(dev)
def circuit():
qml.Reflection(U)
return qml.state()


pycon
>>> circuit()
tensor([0.-6.123234e-17j, 1.+6.123234e-17j], requires_grad=True)


* Performing qubitization is now easily accessible with the new `qml.Qubitization` operator. [(5500)](https://github.com/PennyLaneAI/pennylane/pull/5500)

`qml.Qubitization` encodes a Hamiltonian into a suitable unitary operator. When applied in conjunction with quantum phase estimation (QPE), it allows for computing the eigenvalue of an eigenvector of the given Hamiltonian.

python
H = qml.dot([0.1, 0.3, -0.3], [qml.Z(0), qml.Z(1), qml.Z(0) qml.Z(2)])
qml.qnode(qml.device("default.qubit"))
def circuit():
initialize the eigenvector
qml.PauliX(2)
apply QPE
measurements = qml.iterative_qpe(
qml.Qubitization(H, control = [3,4]), ancilla = 5, iters = 3
)
return qml.probs(op = measurements)


<h4>Make use of more methods to map from molecules 🗺️</h4>

* A new function called `qml.bravyi_kitaev` has been added to perform the Bravyi-Kitaev mapping of fermionic Hamiltonians to qubit Hamiltonians. [(5390)](https://github.com/PennyLaneAI/pennylane/pull/5390)

This function presents an alternative mapping to `qml.jordan_wigner` or `qml.parity_transform` which can help us measure expectation values more efficiently on hardware. Simply provide a fermionic Hamiltonian (created from `from_string`, `FermiA`, `FermiC`, `FermiSentence`, or `FermiWord`) and the number of qubits / spin orbitals in the system, `n`:

pycon
>>> fermi_ham = qml.fermi.from_string('0+ 1+ 1- 0-')
>>> qubit_ham = qml.bravyi_kitaev(fermi_ham, n=6, tol=0.0)
>>> print(qubit_ham)
0.25 * I(0) + -0.25 * Z(0) + -0.25 * (Z(0) Z(1)) + 0.25 * Z(1)


* The `qml.qchem.hf_state` function has been upgraded to be compatible with `qml.parity_transform` and the new Bravyi-Kitaev mapping (`qml.bravyi_kitaev`). [(5472)](https://github.com/PennyLaneAI/pennylane/pull/5472) [(#5472)](https://github.com/PennyLaneAI/pennylane/pull/5472)

pycon
>>> state_bk = qml.qchem.hf_state(2, 6, basis="bravyi_kitaev")
>>> print(state_bk)
[1 0 0 0 0 0]
>>> state_parity = qml.qchem.hf_state(2, 6, basis="parity")
>>> print(state_parity)
[1 0 0 0 0 0]


<h4>Calculate dynamical Lie algebras 👾</h4>

The dynamical Lie algebra (DLA) of a set of operators captures the range of unitary evolutions that the operators can generate. In v0.36 of PennyLane, we have added support for calculating important DLA concepts including:

* A new `qml.lie_closure` function to compute the Lie closure of a list of operators, providing one way to obtain the DLA. [(5161)](https://github.com/PennyLaneAI/pennylane/pull/5161) [(#5169)](https://github.com/PennyLaneAI/pennylane/pull/5169) [(#5627)](https://github.com/PennyLaneAI/pennylane/pull/5627)

For a list of operators `ops = [op1, op2, op3, ..]`, one computes all nested commutators between `ops` until no new operators are generated from commutation. All these operators together form the DLA, see e.g. section IIB of [arXiv:2308.01432](https://arxiv.org/abs/2308.01432).

Take for example the following operators:

python
from pennylane import X, Y, Z
ops = [X(0) X(1), Z(0), Z(1)]


A first round of commutators between all elements yields the new operators `Y(0) X(1)` and `X(0) Y(1)` (omitting scalar prefactors).

python
>>> qml.commutator(X(0) X(1), Z(0))
-2j * (Y(0) X(1))
>>> qml.commutator(X(0) X(1), Z(1))
-2j * (X(0) Y(1))


A next round of commutators between all elements further yields the new operator `Y(0) Y(1)`.

python
>>> qml.commutator(X(0) Y(1), Z(0))
-2j * (Y(0) Y(1))


After that, no new operators emerge from taking nested commutators and we have the resulting DLA. This can now be done in short via `qml.lie_closure` as follows.

python
>>> ops = [X(0) X(1), Z(0), Z(1)]
>>> dla = qml.lie_closure(ops)
>>> dla
[X(0) X(1), Z(0), Z(1), -1.0 * (Y(0) X(1)), -1.0 * (X(0) Y(1)), -1.0 * (Y(0) Y(1))]


* Computing the structure constants (the adjoint representation) of a dynamical Lie algebra. [(5406)](https://github.com/PennyLaneAI/pennylane/pull/5406)

For example, we can compute the adjoint representation of the transverse field Ising model DLA.

pycon
>>> dla = [X(0) X(1), Z(0), Z(1), Y(0) X(1), X(0) Y(1), Y(0) Y(1)]
>>> structure_const = qml.structure_constants(dla)
>>> structure_const.shape
(6, 6, 6)


Visit the [documentation of qml.structure_constants](https://docs.pennylane.ai/en/stable/code/api/pennylane.structure_constants.html) to understand how structure constants are a useful way to represent a DLA.

* Computing the center of a dynamical Lie algebra. [(5477)](https://github.com/PennyLaneAI/pennylane/pull/5477)

Given a DLA `g`, we can now compute its centre. The `center` is the collection of operators that commute with _all_ other operators in the DLA.

pycon
>>> g = [X(0), X(1) X(0), Y(1), Z(1) X(0)]
>>> qml.center(g)
[X(0)]


To help explain these concepts, check out the [dynamical Lie algebras demo](https://pennylane.ai/qml/demos/tutorial_liealgebra).

<h3>Improvements 🛠</h3>

<h4>Simulate mixed-state qutrit systems</h4>

* Mixed qutrit states can now be simulated with the `default.qutrit.mixed` device. [(5495)](https://github.com/PennyLaneAI/pennylane/pull/5495) [(#5451)](https://github.com/PennyLaneAI/pennylane/pull/5451) [(#5186)](https://github.com/PennyLaneAI/pennylane/pull/5186) [(#5082)](https://github.com/PennyLaneAI/pennylane/pull/5082) [(#5213)](https://github.com/PennyLaneAI/pennylane/pull/5213)

Thanks to contributors from the University of British Columbia, a mixed-state qutrit device is now available for simulation, providing a noise-capable equivalent to `default.qutrit`.

python
dev = qml.device("default.qutrit.mixed")

def circuit():
qml.TRY(0.1, wires=0)

qml.qnode(dev)
def shots_circuit():
circuit()
return qml.sample(), qml.expval(qml.GellMann(wires=0, index=1))

qml.qnode(dev)
def density_matrix_circuit():
circuit()
return qml.state()


pycon
>>> shots_circuit(shots=5)
(array([0, 0, 0, 0, 0]), 0.19999999999999996)
>>> density_matrix_circuit()
tensor([[0.99750208+0.j, 0.04991671+0.j, 0. +0.j], [0.04991671+0.j, 0.00249792+0.j, 0. +0.j], [0. +0.j, 0. +0.j, 0. +0.j]], requires_grad=True)


However, there's one crucial ingredient that we still need to add: support for qutrit noise operations. Keep your eyes peeled for this to arrive in the coming releases!

<h4>Work easily and efficiently with operators</h4>

* This release completes the main phase of PennyLane's switchover to an updated approach for handling arithmetic operations between operators. The new approach is now enabled by default and is intended to realize a few objectives: 1. To make it as easy to work with PennyLane operators as it would be with pen and paper. 2. To improve the efficiency of operator arithmetic.

In many cases, this update should not break code. If issues do arise, check out the [updated operator troubleshooting page](https://docs.pennylane.ai/en/stable/news/new_opmath.html) and don't hesitate to reach out to us on the [PennyLane discussion forum](https://discuss.pennylane.ai/). As a last resort the old behaviour can be enabled by calling `qml.operation.disable_new_opmath()`, but this is not recommended because support will not continue in future PennyLane versions (v0.36 and higher). [(#5269)](https://github.com/PennyLaneAI/pennylane/pull/5269)

* A new class called `qml.ops.LinearCombination` has been introduced. In essence, this class is an updated equivalent of the now-deprecated `qml.ops.Hamiltonian` but for usage with the new operator arithmetic. [(5216)](https://github.com/PennyLaneAI/pennylane/pull/5216)

* `qml.ops.Sum` now supports storing grouping information. Grouping type and method can be specified during construction using the `grouping_type` and `method` keyword arguments of `qml.dot`, `qml.sum`, or `qml.ops.Sum`. The grouping indices are stored in `Sum.grouping_indices`. [(5179)](https://github.com/PennyLaneAI/pennylane/pull/5179)

python
a = qml.X(0)
b = qml.prod(qml.X(0), qml.X(1))
c = qml.Z(0)
obs = [a, b, c]
coeffs = [1.0, 2.0, 3.0]

op = qml.dot(coeffs, obs, grouping_type="qwc")


pycon
>>> op.grouping_indices
((2,), (0, 1))


Additionally, `grouping_type` and `method` can be set or changed after construction using `Sum.compute_grouping()`:

python
a = qml.X(0)
b = qml.prod(qml.X(0), qml.X(1))
c = qml.Z(0)
obs = [a, b, c]
coeffs = [1.0, 2.0, 3.0]

op = qml.dot(coeffs, obs)


pycon
>>> op.grouping_indices is None
True
>>> op.compute_grouping(grouping_type="qwc")
>>> op.grouping_indices
((2,), (0, 1))


Note that the grouping indices refer to the lists returned by `Sum.terms()`, not `Sum.operands`.

* A new function called `qml.operation.convert_to_legacy_H` that converts `Sum`, `SProd`, and `Prod` to `Hamiltonian` instances has been added. This function is intended for developers and will be removed in a future release without a deprecation cycle. [(5309)](https://github.com/PennyLaneAI/pennylane/pull/5309)

* The `qml.is_commuting` function now accepts `Sum`, `SProd`, and `Prod` instances. [(5351)](https://github.com/PennyLaneAI/pennylane/pull/5351)

* Operators can now be left-multiplied by NumPy arrays (i.e., `arr * op`). [(5361)](https://github.com/PennyLaneAI/pennylane/pull/5361)

* `op.generator()`, where `op` is an `Operator` instance, now returns operators consistent with the global setting for `qml.operator.active_new_opmath()` wherever possible. `Sum`, `SProd` and `Prod` instances will be returned even after disabling the new operator arithmetic in cases where they offer additional functionality not available using legacy operators. [(5253)](https://github.com/PennyLaneAI/pennylane/pull/5253) [(#5410)](https://github.com/PennyLaneAI/pennylane/pull/5410) [(#5411)](https://github.com/PennyLaneAI/pennylane/pull/5411) [(#5421)](https://github.com/PennyLaneAI/pennylane/pull/5421)

* `Prod` instances temporarily have a new `obs` property, which helps smoothen the transition of the new operator arithmetic system. In particular, this is aimed at preventing breaking code that uses `Tensor.obs`. The property has been immediately deprecated. Moving forward, we recommend using `op.operands`. [(5539)](https://github.com/PennyLaneAI/pennylane/pull/5539)

* `qml.ApproxTimeEvolution` is now compatible with any operator that has a defined `pauli_rep`. [(5362)](https://github.com/PennyLaneAI/pennylane/pull/5362)

* `Hamiltonian.pauli_rep` is now defined if the Hamiltonian is a linear combination of Pauli operators. [(5377)](https://github.com/PennyLaneAI/pennylane/pull/5377)

* `Prod` instances created with qutrit operators now have a defined `eigvals()` method. [(5400)](https://github.com/PennyLaneAI/pennylane/pull/5400)

* `qml.transforms.hamiltonian_expand` and `qml.transforms.sum_expand` can now handle multi-term observables with a constant offset (i.e., terms like `qml.I()`). [(5414)](https://github.com/PennyLaneAI/pennylane/pull/5414) [(#5543)](https://github.com/PennyLaneAI/pennylane/pull/5543)

* `qml.qchem.taper_operation` is now compatible with the new operator arithmetic. [(5326)](https://github.com/PennyLaneAI/pennylane/pull/5326)

* The warning for an observable that might not be hermitian in QNode executions has been removed. This enables jit-compilation. [(5506)](https://github.com/PennyLaneAI/pennylane/pull/5506)

* `qml.transforms.split_non_commuting` will now work with single-term operator arithmetic. [(5314)](https://github.com/PennyLaneAI/pennylane/pull/5314)

* `LinearCombination` and `Sum` now accept `_grouping_indices` on initialization. This addition is relevant to developers only. [(5524)](https://github.com/PennyLaneAI/pennylane/pull/5524)

* Calculating the dense, differentiable matrix for `PauliSentence` and operators with Pauli sentences is now faster. [(5578)](https://github.com/PennyLaneAI/pennylane/pull/5578)

<h4>Community contributions 🥳</h4>

* `ExpectationMP`, `VarianceMP`, `CountsMP`, and `SampleMP` now have a `process_counts` method (similar to `process_samples`). This allows for calculating measurements given a `counts` dictionary. [(5256)](https://github.com/PennyLaneAI/pennylane/pull/5256) [(#5395)](https://github.com/PennyLaneAI/pennylane/pull/5395)

* Type-hinting has been added in the `Operator` class for better interpretability. [(5490)](https://github.com/PennyLaneAI/pennylane/pull/5490)

* An alternate strategy for sampling with multiple different `shots` values has been implemented via the `shots.bins()` method, which samples all shots at once and then processes each separately. [(5476)](https://github.com/PennyLaneAI/pennylane/pull/5476)

<h4>Mid-circuit measurements and dynamic circuits</h4>

* A new module called `qml.capture` that will contain PennyLane's own capturing mechanism for hybrid quantum-classical programs has been added. [(5509)](https://github.com/PennyLaneAI/pennylane/pull/5509)

* The `dynamic_one_shot` transform has been introduced, enabling dynamic circuit execution on circuits with finite `shots` and devices that natively support mid-circuit measurements. [(5266)](https://github.com/PennyLaneAI/pennylane/pull/5266)

* The `QubitDevice` class and children classes support the `dynamic_one_shot` transform provided that they support mid-circuit measurement operations natively. [(5317)](https://github.com/PennyLaneAI/pennylane/pull/5317)

* `default.qubit` can now be provided a random seed for sampling mid-circuit measurements with finite shots. This (1) ensures that random behaviour is more consistent with `dynamic_one_shot` and `defer_measurements` and (2) makes our continuous-integration (CI) have less failures due to stochasticity. [(5337)](https://github.com/PennyLaneAI/pennylane/pull/5337)

<h4>Performance and broadcasting</h4>

* Gradient transforms may now be applied to batched/broadcasted QNodes as long as the broadcasting is in non-trainable parameters. [(5452)](https://github.com/PennyLaneAI/pennylane/pull/5452)

* The performance of computing the matrix of `qml.QFT` has been improved. [(5351)](https://github.com/PennyLaneAI/pennylane/pull/5351)

* `qml.transforms.broadcast_expand` now supports shot vectors when returning `qml.sample()`. [(5473)](https://github.com/PennyLaneAI/pennylane/pull/5473)

* `LightningVJPs` is now compatible with Lightning devices using the new device API. [(5469)](https://github.com/PennyLaneAI/pennylane/pull/5469)

<h4>Device capabilities</h4>

* Obtaining classical shadows using the `default.clifford` device is now compatible with [stim](https://github.com/quantumlib/Stim) `v1.13.0`. [(#5409)](https://github.com/PennyLaneAI/pennylane/pull/5409)

* `default.mixed` has improved support for sampling-based measurements with non-NumPy interfaces. [(5514)](https://github.com/PennyLaneAI/pennylane/pull/5514) [(#5530)](https://github.com/PennyLaneAI/pennylane/pull/5530)

* `default.mixed` now supports arbitrary state-based measurements with `qml.Snapshot`. [(5552)](https://github.com/PennyLaneAI/pennylane/pull/5552)

* `null.qubit` has been upgraded to the new device API and has support for all measurements and various modes of differentiation. [(5211)](https://github.com/PennyLaneAI/pennylane/pull/5211)

<h4>Other improvements</h4>

* Entanglement entropy can now be calculated with `qml.math.vn_entanglement_entropy`, which computes the von Neumann entanglement entropy from a density matrix. A corresponding QNode transform, `qml.qinfo.vn_entanglement_entropy`, has also been added. [(5306)](https://github.com/PennyLaneAI/pennylane/pull/5306)

* `qml.draw` and `qml.draw_mpl` will now attempt to sort the wires if no wire order is provided by the user or the device. [(5576)](https://github.com/PennyLaneAI/pennylane/pull/5576)

* A clear error message is added in `KerasLayer` when using the newest version of TensorFlow with Keras 3 (which is not currently compatible with `KerasLayer`), linking to instructions to enable Keras 2. [(5488)](https://github.com/PennyLaneAI/pennylane/pull/5488)

* `qml.ops.Conditional` now stores the `data`, `num_params`, and `ndim_param` attributes of the operator it wraps. [(5473)](https://github.com/PennyLaneAI/pennylane/pull/5473)

* The `molecular_hamiltonian` function calls `PySCF` directly when `method='pyscf'` is selected. [(5118)](https://github.com/PennyLaneAI/pennylane/pull/5118)

* `cache_execute` has been replaced with an alternate implementation based on `transform`. [(5318)](https://github.com/PennyLaneAI/pennylane/pull/5318)

* QNodes now defer `diff_method` validation to the device under the new device API. [(5176)](https://github.com/PennyLaneAI/pennylane/pull/5176)

* The device test suite has been extended to cover gradient methods, templates and arithmetic observables. [(5273)](https://github.com/PennyLaneAI/pennylane/pull/5273) [(#5518)](https://github.com/PennyLaneAI/pennylane/pull/5518)

* A typo and string formatting mistake have been fixed in the error message for `ClassicalShadow._convert_to_pauli_words` when the input is not a valid `pauli_rep`. [(5572)](https://github.com/PennyLaneAI/pennylane/pull/5572)

* Circuits running on `lightning.qubit` and that return `qml.state()` now preserve the `dtype` when specified. [(5547)](https://github.com/PennyLaneAI/pennylane/pull/5547)

<h3>Breaking changes 💔</h3>

* `qml.matrix()` called on the following will now raise an error if `wire_order` is not specified: * tapes with more than one wire * quantum functions * `Operator` classes where `num_wires` does not equal to 1 * QNodes if the device does not have wires specified. * `PauliWord`s and `PauliSentence`s with more than one wire. [(5328)](https://github.com/PennyLaneAI/pennylane/pull/5328) [(#5359)](https://github.com/PennyLaneAI/pennylane/pull/5359)

* `single_tape_transform`, `batch_transform`, `qfunc_transform`, `op_transform`, `gradient_transform` and `hessian_transform` have been removed. Instead, switch to using the new `qml.transform` function. Please refer to `the transform docs <https://docs.pennylane.ai/en/stable/code/qml_transforms.html#custom-transforms>`_ to see how this can be done. [(5339)](https://github.com/PennyLaneAI/pennylane/pull/5339)

* Attempting to multiply `PauliWord` and `PauliSentence` with `*` will raise an error. Instead, use `` to conform with the PennyLane convention. [(5341)](https://github.com/PennyLaneAI/pennylane/pull/5341)

* `DefaultQubit` now uses a pre-emptive key-splitting strategy to avoid reusing JAX PRNG keys throughout a single `execute` call. [(5515)](https://github.com/PennyLaneAI/pennylane/pull/5515)

* `qml.pauli.pauli_mult` and `qml.pauli.pauli_mult_with_phase` have been removed. Instead, use `qml.simplify(qml.prod(pauli_1, pauli_2))` to get the reduced operator. [(5324)](https://github.com/PennyLaneAI/pennylane/pull/5324)

pycon
>>> op = qml.simplify(qml.prod(qml.PauliX(0), qml.PauliZ(0)))
>>> op -1j*(PauliY(wires=[0]))
>>> [phase], [base] = op.terms()
>>> phase, base
(-1j, PauliY(wires=[0]))


* The `dynamic_one_shot` transform now uses sampling (`SampleMP`) to get back the values of the mid-circuit measurements. [(5486)](https://github.com/PennyLaneAI/pennylane/pull/5486)

* `Operator` dunder methods now combine like-operator arithmetic classes via `lazy=False`. This reduces the chances of getting a `RecursionError` and makes nested operators easier to work with. [(5478)](https://github.com/PennyLaneAI/pennylane/pull/5478)

* The private functions `_pauli_mult`, `_binary_matrix` and `_get_pauli_map` from the `pauli` module have been removed. The same functionality can be achieved using newer features in the `pauli` module. [(5323)](https://github.com/PennyLaneAI/pennylane/pull/5323)

* `MeasurementProcess.name` and `MeasurementProcess.data` have been removed. Use `MeasurementProcess.obs.name` and `MeasurementProcess.obs.data` instead. [(5321)](https://github.com/PennyLaneAI/pennylane/pull/5321)

* `Operator.validate_subspace(subspace)` has been removed. Instead, use `qml.ops.qutrit.validate_subspace(subspace)`. [(5311)](https://github.com/PennyLaneAI/pennylane/pull/5311)

* The contents of `qml.interfaces` has been moved inside `qml.workflow`. The old import path no longer exists. [(5329)](https://github.com/PennyLaneAI/pennylane/pull/5329)

* Since `default.mixed` does not support snapshots with measurements, attempting to do so will result in a `DeviceError` instead of getting the density matrix. [(5416)](https://github.com/PennyLaneAI/pennylane/pull/5416)

* `LinearCombination._obs_data` has been removed. You can still use `LinearCombination.compare` to check mathematical equivalence between a `LinearCombination` and another operator. [(5504)](https://github.com/PennyLaneAI/pennylane/pull/5504)

<h3>Deprecations 👋</h3>

* Accessing `qml.ops.Hamiltonian` is deprecated because it points to the old version of the class that may not be compatible with the new approach to operator arithmetic. Instead, using `qml.Hamiltonian` is recommended because it dispatches to the `LinearCombination` class when the new approach to operator arithmetic is enabled. This will allow you to continue to use `qml.Hamiltonian` with existing code without needing to make any changes. [(5393)](https://github.com/PennyLaneAI/pennylane/pull/5393)

* `qml.load` has been deprecated. Instead, please use the functions outlined in the [Importing workflows quickstart guide](https://docs.pennylane.ai/en/latest/introduction/importing_workflows.html). [(#5312)](https://github.com/PennyLaneAI/pennylane/pull/5312)

* Specifying `control_values` with a bit string in `qml.MultiControlledX` has been deprecated. Instead, use a list of booleans or 1s and 0s. [(5352)](https://github.com/PennyLaneAI/pennylane/pull/5352)

* `qml.from_qasm_file` has been deprecated. Instead, please open the file and then load its content using `qml.from_qasm`. [(5331)](https://github.com/PennyLaneAI/pennylane/pull/5331)

pycon
>>> with open("test.qasm", "r") as f:
... circuit = qml.from_qasm(f.read())


<h3>Documentation 📝</h3>

* [A new page](https://docs.pennylane.ai/en/latest/code/qml_workflow.html#return-type-specification) explaining the shapes and nesting of return types has been added. [(5418)](https://github.com/PennyLaneAI/pennylane/pull/5418)

* Redundant documentation for the `evolve` function has been removed. [(5347)](https://github.com/PennyLaneAI/pennylane/pull/5347)

* The final example in the `compile` docstring has been updated to use transforms correctly. [(5348)](https://github.com/PennyLaneAI/pennylane/pull/5348)

* A link to the demos for using `qml.SpecialUnitary` and `qml.QNGOptimizer` has been added to their respective docstrings. [(5376)](https://github.com/PennyLaneAI/pennylane/pull/5376)

* A code example in the `qml.measure` docstring has been added that showcases returning mid-circuit measurement statistics from QNodes. [(5441)](https://github.com/PennyLaneAI/pennylane/pull/5441)

* The computational basis convention used for `qml.measure` — 0 and 1 rather than ±1 — has been clarified in its docstring. [(5474)](https://github.com/PennyLaneAI/pennylane/pull/5474)

* A new *Release news* section has been added to the table of contents, containing release notes, deprecations, and other pages focusing on recent changes. [(5548)](https://github.com/PennyLaneAI/pennylane/pull/5548)

* A summary of all changes has been added in the "Updated Operators" page in the new "Release news" section in the docs. [(5483)](https://github.com/PennyLaneAI/pennylane/pull/5483) [(#5636)](https://github.com/PennyLaneAI/pennylane/pull/5636)

<h3>Bug fixes 🐛</h3>

* Patches the QNode so that parameter-shift will be considered best with lightning if `qml.metric_tensor` is in the transform program. [(5624)](https://github.com/PennyLaneAI/pennylane/pull/5624)

* Stopped printing the ID of `qcut.MeasureNode` and `qcut.PrepareNode` in tape drawing. [(5613)](https://github.com/PennyLaneAI/pennylane/pull/5613)

* Improves the error message for setting shots on the new device interface, or trying to access a property that no longer exists. [(5616)](https://github.com/PennyLaneAI/pennylane/pull/5616)

* Fixed a bug where `qml.draw` and `qml.draw_mpl` incorrectly raised errors for circuits collecting statistics on mid-circuit measurements while using `qml.defer_measurements`. [(5610)](https://github.com/PennyLaneAI/pennylane/pull/5610)

* Using shot vectors with `param_shift(... broadcast=True)` caused a bug. This combination is no longer supported and will be added again in the next release. Fixed a bug with custom gradient recipes that only consist of unshifted terms. [(5612)](https://github.com/PennyLaneAI/pennylane/pull/5612) [(#5623)](https://github.com/PennyLaneAI/pennylane/pull/5623)

* `qml.counts` now returns the same keys with `dynamic_one_shot` and `defer_measurements`. [(5587)](https://github.com/PennyLaneAI/pennylane/pull/5587)

* `null.qubit` now automatically supports any operation without a decomposition. [(5582)](https://github.com/PennyLaneAI/pennylane/pull/5582)

* Fixed a bug where the shape and type of derivatives obtained by applying a gradient transform to a QNode differed based on whether the QNode uses classical coprocessing. [(4945)](https://github.com/PennyLaneAI/pennylane/pull/4945)

* `ApproxTimeEvolution`, `CommutingEvolution`, `QDrift`, and `TrotterProduct` now de-queue their input observable. [(5524)](https://github.com/PennyLaneAI/pennylane/pull/5524)

* (In)equality of `qml.HilbertSchmidt` instances is now reported correctly by `qml.equal`. [(5538)](https://github.com/PennyLaneAI/pennylane/pull/5538)

* `qml.ParticleConservingU1` and `qml.ParticleConservingU2` no longer raise an error when the initial state is not specified but default to the all-zeros state. [(5535)](https://github.com/PennyLaneAI/pennylane/pull/5535)

* `qml.counts` no longer returns negative samples when measuring 8 or more wires. [(5544)](https://github.com/PennyLaneAI/pennylane/pull/5544) [(#5556)](https://github.com/PennyLaneAI/pennylane/pull/5556)

* The `dynamic_one_shot` transform now works with broadcasting. [(5473)](https://github.com/PennyLaneAI/pennylane/pull/5473)

* Diagonalizing gates are now applied when measuring `qml.probs` on non-computational basis states on a Lightning device. [(5529)](https://github.com/PennyLaneAI/pennylane/pull/5529)

* `two_qubit_decomposition` no longer diverges at a special case of a unitary matrix. [(5448)](https://github.com/PennyLaneAI/pennylane/pull/5448)

* The `qml.QNSPSAOptimizer` now correctly handles optimization for legacy devices that do not follow the new device API. [(5497)](https://github.com/PennyLaneAI/pennylane/pull/5497)

* Operators applied to all wires are now drawn correctly in a circuit with mid-circuit measurements. [(5501)](https://github.com/PennyLaneAI/pennylane/pull/5501)

* Fixed a bug where certain unary mid-circuit measurement expressions would raise an uncaught error. [(5480)](https://github.com/PennyLaneAI/pennylane/pull/5480)

* Probabilities now sum to 1 when using the `torch` interface with `default_dtype` set to `torch.float32`. [(5462)](https://github.com/PennyLaneAI/pennylane/pull/5462)

* Tensorflow can now handle devices with `float32` results but `float64` input parameters. [(5446)](https://github.com/PennyLaneAI/pennylane/pull/5446)

* Fixed a bug where the `argnum` keyword argument of `qml.gradients.stoch_pulse_grad` references the wrong parameters in a tape, creating an inconsistency with other differentiation methods and preventing some use cases. [(5458)](https://github.com/PennyLaneAI/pennylane/pull/5458)

* Bounded value failures due to numerical noise with calls to `np.random.binomial` is now avoided. [(5447)](https://github.com/PennyLaneAI/pennylane/pull/5447)

* Using `` with legacy Hamiltonian instances now properly de-queues the previously existing operations. [(5455)](https://github.com/PennyLaneAI/pennylane/pull/5455)

* The `QNSPSAOptimizer` now properly handles differentiable parameters, resulting in being able to use it for more than one optimization step. [(5439)](https://github.com/PennyLaneAI/pennylane/pull/5439)

* The QNode interface now resets if an error occurs during execution. [(5449)](https://github.com/PennyLaneAI/pennylane/pull/5449)

* Failing tests due to changes with Lightning's adjoint diff pipeline have been fixed. [(5450)](https://github.com/PennyLaneAI/pennylane/pull/5450)

* Failures occurring when making autoray-dispatched calls to Torch with paired CPU data have been fixed. [(5438)](https://github.com/PennyLaneAI/pennylane/pull/5438)

* `jax.jit` now works with `qml.sample` with a multi-wire observable. [(5422)](https://github.com/PennyLaneAI/pennylane/pull/5422)

* `qml.qinfo.quantum_fisher` now works with non-`default.qubit` devices. [(5423)](https://github.com/PennyLaneAI/pennylane/pull/5423)

* We no longer perform unwanted `dtype` promotion in the `pauli_rep` of `SProd` instances when using Tensorflow. [(5246)](https://github.com/PennyLaneAI/pennylane/pull/5246)

* Fixed `TestQubitIntegration.test_counts` in `tests/interfaces/test_jax_qnode.py` to always produce counts for all outcomes. [(5336)](https://github.com/PennyLaneAI/pennylane/pull/5336)

* Fixed `PauliSentence.to_mat(wire_order)` to support identities with wires. [(5407)](https://github.com/PennyLaneAI/pennylane/pull/5407)

* `CompositeOp.map_wires` now correctly maps the `overlapping_ops` property. [(5430)](https://github.com/PennyLaneAI/pennylane/pull/5430)

* `DefaultQubit.supports_derivatives` has been updated to correctly handle circuits containing mid-circuit measurements and adjoint differentiation. [(5434)](https://github.com/PennyLaneAI/pennylane/pull/5434)

* `SampleMP`, `ExpectationMP`, `CountsMP`, and `VarianceMP` constructed with `eigvals` can now properly process samples. [(5463)](https://github.com/PennyLaneAI/pennylane/pull/5463)

* Fixed a bug in `hamiltonian_expand` that produces incorrect output dimensions when shot vectors are combined with parameter broadcasting. [(5494)](https://github.com/PennyLaneAI/pennylane/pull/5494)

* `default.qubit` now allows measuring `Identity` on no wires and observables containing `Identity` on no wires. [(5570)](https://github.com/PennyLaneAI/pennylane/pull/5570/)

* Fixed a bug where `TorchLayer` does not work with shot vectors. [(5492)](https://github.com/PennyLaneAI/pennylane/pull/5492)

* Fixed a bug where the output shape of a QNode returning a list containing a single measurement is incorrect when combined with shot vectors. [(5492)](https://github.com/PennyLaneAI/pennylane/pull/5492)

* Fixed a bug in `qml.math.kron` that makes Torch incompatible with NumPy. [(5540)](https://github.com/PennyLaneAI/pennylane/pull/5540)

* Fixed a bug in `_group_measurements` that fails to group measurements with commuting observables when they are operands of `Prod`. [(5525)](https://github.com/PennyLaneAI/pennylane/pull/5525)

* `qml.equal` can now be used with sums and products that contain operators on no wires like `I` and `GlobalPhase`. [(5562)](https://github.com/PennyLaneAI/pennylane/pull/5562)

* `CompositeOp.has_diagonalizing_gates` now does a more complete check of the base operators to ensure consistency between `op.has_diagonalzing_gates` and `op.diagonalizing_gates()` [(5603)](https://github.com/PennyLaneAI/pennylane/pull/5603)

* Updated the `method` kwarg of `qml.TrotterProduct().error()` to be more clear that we are computing upper-bounds. [(5637)](https://github.com/PennyLaneAI/pennylane/pull/5637)

<h3>Contributors ✍️</h3>

This release contains contributions from (in alphabetical order):

Tarun Kumar Allamsetty, Guillermo Alonso, Mikhail Andrenkov, Utkarsh Azad, Gabriel Bottrill, Thomas Bromley, Astral Cai, Diksha Dhawan, Isaac De Vlugt, Amintor Dusko, Pietropaolo Frisoni, Lillian M. A. Frederiksen, Diego Guala, Austin Huang, Soran Jahangiri, Korbinian Kottmann, Christina Lee, Vincent Michaud-Rioux, Mudit Pandey, Kenya Sakka, Jay Soni, Matthew Silverman, David Wierichs.

<h3>Bug fixes 🐛</h3>

* Lightning simulators need special handling of diagonalizing gates when performing sampling measurements. [(5343)](https://github.com/PennyLaneAI/pennylane/pull/5343)

* Updated the lower bound on the required Catalyst version to `v0.5.0`. [(5320)](https://github.com/PennyLaneAI/pennylane/pull/5320)

<h3>Contributors ✍️</h3>

This release contains contributions from (in alphabetical order):

Vincent Michaud-Rioux, Erick Ochoa Lopez.