Pennylane

This postfix release pins additional requirements in `doc/requirements.txt` for building the website documentation. This allows the website to be rebuilt to show the "Getting involved" section.

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

<h4>Statistics and drawing for mid-circuit measurements 🎨</h4>

* It is now possible to return statistics of composite mid-circuit measurements. [(4888)](https://github.com/PennyLaneAI/pennylane/pull/4888)

Mid-circuit measurement results can be composed using basic arithmetic operations and then statistics can be calculated by putting the result within a PennyLane [measurement](https://docs.pennylane.ai/en/stable/introduction/measurements.html) like `qml.expval()`. For example:

python
import pennylane as qml

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

qml.qnode(dev)
def circuit(phi, theta):
qml.RX(phi, wires=0)
m0 = qml.measure(wires=0)
qml.RY(theta, wires=1)
m1 = qml.measure(wires=1)
return qml.expval(~m0 + m1)

print(circuit(1.23, 4.56))


1.2430187928114291


Another option, for ease-of-use when using `qml.sample()`, `qml.probs()`, or `qml.counts()`, is to provide a simple list of mid-circuit measurement results:

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

qml.qnode(dev)
def circuit(phi, theta):
qml.RX(phi, wires=0)
m0 = qml.measure(wires=0)
qml.RY(theta, wires=1)
m1 = qml.measure(wires=1)
return qml.sample(op=[m0, m1])

print(circuit(1.23, 4.56, shots=5))



[[0 1]
[0 1]
[0 0]
[1 0]
[0 1]]


Composite mid-circuit measurement statistics are supported on `default.qubit` and `default.mixed`. To learn more about which measurements and arithmetic operators are supported, [refer to the measurements page](https://docs.pennylane.ai/en/stable/introduction/measurements.html) and the [documentation for qml.measure](https://docs.pennylane.ai/en/stable/code/api/pennylane.measure.html).

* Mid-circuit measurements can now be visualized with the text-based `qml.draw()` and the graphical `qml.draw_mpl()` methods. [(4775)](https://github.com/PennyLaneAI/pennylane/pull/4775) [(#4803)](https://github.com/PennyLaneAI/pennylane/pull/4803) [(#4832)](https://github.com/PennyLaneAI/pennylane/pull/4832) [(#4901)](https://github.com/PennyLaneAI/pennylane/pull/4901) [(#4850)](https://github.com/PennyLaneAI/pennylane/pull/4850) [(#4917)](https://github.com/PennyLaneAI/pennylane/pull/4917) [(#4930)](https://github.com/PennyLaneAI/pennylane/pull/4930) [(#4957)](https://github.com/PennyLaneAI/pennylane/pull/4957)

Drawing of mid-circuit measurement capabilities including qubit reuse and reset, postselection, conditioning, and collecting statistics is now supported. Here is an all-encompassing example:

python
def circuit():
m0 = qml.measure(0, reset=True)
m1 = qml.measure(1, postselect=1)
qml.cond(m0 - m1 == 0, qml.S)(0)
m2 = qml.measure(1)
qml.cond(m0 + m1 == 2, qml.T)(0)
qml.cond(m2, qml.PauliX)(1)


The text-based drawer outputs:

pycon
>>> print(qml.draw(circuit)())
0: ──┤↗│ │0⟩────────S───────T────┤
1: ───║────────┤↗₁├──║──┤↗├──║──X─┤
╚═════════║════╬═══║═══╣ ║
╚════╩═══║═══╝ ║
╚══════╝


The graphical drawer outputs:

pycon
>>> print(qml.draw_mpl(circuit)())


<img src="https://raw.githubusercontent.com/PennyLaneAI/pennylane/master/doc/_static/mid-circuit-measurement.png" width=70%/>

<h4>Catalyst is seamlessly integrated with PennyLane ⚗️</h4>

* Catalyst, our next-generation compilation framework, is now accessible within PennyLane, allowing you to more easily benefit from hybrid just-in-time (JIT) compilation.

To access these features, simply install `pennylane-catalyst`:


pip install pennylane-catalyst


The [qml.compiler](https://docs.pennylane.ai/en/latest/code/qml_compiler.html) module provides support for hybrid quantum-classical compilation. [(#4692)](https://github.com/PennyLaneAI/pennylane/pull/4692) [(#4979)](https://github.com/PennyLaneAI/pennylane/pull/4979)

Through the use of the `qml.qjit` decorator, entire workflows can be JIT compiled — including both quantum and classical processing — down to a machine binary on first-function execution. Subsequent calls to the compiled function will execute the previously-compiled binary, resulting in significant performance improvements.

python
import pennylane as qml

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

qml.qjit
qml.qnode(dev)
def circuit(theta):
qml.Hadamard(wires=0)
qml.RX(theta, wires=1)
qml.CNOT(wires=[0,1])
return qml.expval(qml.PauliZ(wires=1))


pycon
>>> circuit(0.5) the first call, compilation occurs here array(0.)
>>> circuit(0.5) the precompiled quantum function is called
array(0.)


Currently, PennyLane supports the [Catalyst hybrid compiler](https://github.com/pennylaneai/catalyst) with the `qml.qjit` decorator. A significant benefit of Catalyst is the ability to preserve complex control flow around quantum operations — such as `if` statements and `for` loops, and including measurement feedback — during compilation, while continuing to support end-to-end autodifferentiation.

* The following functions can now be used with the `qml.qjit` decorator: `qml.grad`, `qml.jacobian`, `qml.vjp`, `qml.jvp`, and `qml.adjoint`. [(4709)](https://github.com/PennyLaneAI/pennylane/pull/4709) [(#4724)](https://github.com/PennyLaneAI/pennylane/pull/4724) [(#4725)](https://github.com/PennyLaneAI/pennylane/pull/4725) [(#4726)](https://github.com/PennyLaneAI/pennylane/pull/4726)

When `qml.grad` or `qml.jacobian` are used with `qml.qjit`, they are patched to [catalyst.grad](https://docs.pennylane.ai/projects/catalyst/en/stable/code/api/catalyst.grad.html) and [catalyst.jacobian](https://docs.pennylane.ai/projects/catalyst/en/stable/code/api/catalyst.jacobian.html), respectively.

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

qml.qjit
def workflow(x):

qml.qnode(dev)
def circuit(x):
qml.RX(np.pi * x[0], wires=0)
qml.RY(x[1], wires=0)
return qml.probs()

g = qml.jacobian(circuit)

return g(x)


pycon
>>> workflow(np.array([2.0, 1.0]))
array([[ 3.48786850e-16, -4.20735492e-01],
[-8.71967125e-17, 4.20735492e-01]])


* JIT-compatible functionality for control flow has been added via `qml.for_loop`, `qml.while_loop`, and `qml.cond`. [(4698)](https://github.com/PennyLaneAI/pennylane/pull/4698)

`qml.for_loop` and `qml.while_loop` can be deployed as decorators on functions that are the body of the loop. The arguments to both follow typical conventions:


qml.for_loop(lower_bound, upper_bound, step)



qml.while_loop(cond_function)


Here is a concrete example with `qml.for_loop`:

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

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

qml.for_loop(0, n, 1)
def loop_rx(i, x):
perform some work and update (some of) the arguments
qml.RX(x, wires=0)

update the value of x for the next iteration
return jnp.sin(x)

apply the for loop
final_x = loop_rx(x)

return qml.expval(qml.PauliZ(0)), final_x


pycon
>>> circuit(7, 1.6)
(array(0.97926626), array(0.55395718))


<h4>Decompose circuits into the Clifford+T gateset 🧩</h4>

* The new `qml.clifford_t_decomposition()` transform provides an approximate breakdown of an input circuit into the [Clifford+T gateset](https://en.wikipedia.org/wiki/Clifford_gates). Behind the scenes, this decomposition is enacted via the `sk_decomposition()` function using the Solovay-Kitaev algorithm. [(#4801)](https://github.com/PennyLaneAI/pennylane/pull/4801) [(#4802)](https://github.com/PennyLaneAI/pennylane/pull/4802)

The Solovay-Kitaev algorithm *approximately* decomposes a quantum circuit into the Clifford+T gateset. To account for this, a desired total circuit decomposition error, `epsilon`, must be specified when using `qml.clifford_t_decomposition`:

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

qml.qnode(dev)
def circuit():
qml.RX(1.1, 0)
return qml.state()

circuit = qml.clifford_t_decomposition(circuit, epsilon=0.1)


pycon
>>> print(qml.draw(circuit)())
0: ──T†──H──T†──H──T──H──T──H──T──H──T──H──T†──H──T†──T†──H──T†──H──T──H──T──H──T──H──T──H──T†──H

───T†──H──T──H──GlobalPhase(0.39)─┤


The resource requirements of this circuit can also be evaluated:

pycon
>>> with qml.Tracker(dev) as tracker:
... circuit()
>>> resources_lst = tracker.history["resources"]
>>> resources_lst[0]
wires: 1
gates: 34
depth: 34
shots: Shots(total=None)
gate_types: {'Adjoint(T)': 8, 'Hadamard': 16, 'T': 9, 'GlobalPhase': 1}
gate_sizes: {1: 33, 0: 1}


<h4>Use an iterative approach for quantum phase estimation 🔄</h4>

* [Iterative Quantum Phase Estimation](https://arxiv.org/pdf/quant-ph/0610214.pdf) is now available with `qml.iterative_qpe`. [(#4804)](https://github.com/PennyLaneAI/pennylane/pull/4804)

The subroutine can be used similarly to mid-circuit measurements:

python
import pennylane as qml

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

qml.qnode(dev)
def circuit():

Initial state
qml.PauliX(wires=[0])

Iterative QPE
measurements = qml.iterative_qpe(qml.RZ(2., wires=[0]), ancilla=[1], iters=3)

return [qml.sample(op=meas) for meas in measurements]


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


The $i$-th element in the list refers to the 5 samples generated by the $i$-th measurement of the algorithm.

<h3>Improvements 🛠</h3>

<h4>Community contributions 🥳</h4>

* The `+=` operand can now be used with a `PauliSentence`, which has also provides a performance boost. [(4662)](https://github.com/PennyLaneAI/pennylane/pull/4662)

* The Approximate Quantum Fourier Transform (AQFT) is now available with `qml.AQFT`. [(4715)](https://github.com/PennyLaneAI/pennylane/pull/4715)

* `qml.draw` and `qml.draw_mpl` now render operator IDs. [(4749)](https://github.com/PennyLaneAI/pennylane/pull/4749)

The ID can be specified as a keyword argument when instantiating an operator:

pycon
>>> def circuit():
... qml.RX(0.123, id="data", wires=0)
>>> print(qml.draw(circuit)())
0: ──RX(0.12,"data")─┤


* Non-parametric operators such as `Barrier`, `Snapshot`, and `Wirecut` have been grouped together and moved to `pennylane/ops/meta.py`. Additionally, the relevant tests have been organized and placed in a new file, `tests/ops/test_meta.py`. [(4789)](https://github.com/PennyLaneAI/pennylane/pull/4789)

* The `TRX`, `TRY`, and `TRZ` operators are now differentiable via backpropagation on `default.qutrit`. [(4790)](https://github.com/PennyLaneAI/pennylane/pull/4790)

* The function `qml.equal` now supports `ControlledSequence` operators. [(4829)](https://github.com/PennyLaneAI/pennylane/pull/4829)

* XZX decomposition has been added to the list of supported single-qubit unitary decompositions. [(4862)](https://github.com/PennyLaneAI/pennylane/pull/4862)

* `==` and `!=` operands can now be used with `TransformProgram` and `TransformContainers` instances. [(4858)](https://github.com/PennyLaneAI/pennylane/pull/4858)

* A `qutrit_mixed` module has been added to `qml.devices` to store helper functions for a future qutrit mixed-state device. A function called `create_initial_state` has been added to this module that creates device-compatible initial states. [(4861)](https://github.com/PennyLaneAI/pennylane/pull/4861)

* The function `qml.Snapshot` now supports arbitrary state-based measurements (i.e., measurements of type `StateMeasurement`). [(4876)](https://github.com/PennyLaneAI/pennylane/pull/4908)

* `qml.equal` now supports the comparison of `QuantumScript` and `BasisRotation` objects. [(4902)](https://github.com/PennyLaneAI/pennylane/pull/4902) [(#4919)](https://github.com/PennyLaneAI/pennylane/pull/4919)

* The function `qml.draw_mpl` now accept a keyword argument `fig` to specify the output figure window. [(4956)](https://github.com/PennyLaneAI/pennylane/pull/4956)

<h4>Better support for batching</h4>

* `qml.AmplitudeEmbedding` now supports batching when used with Tensorflow. [(4818)](https://github.com/PennyLaneAI/pennylane/pull/4818)

* `default.qubit` can now evolve already batched states with `qml.pulse.ParametrizedEvolution`. [(4863)](https://github.com/PennyLaneAI/pennylane/pull/4863)

* `qml.ArbitraryUnitary` now supports batching. [(4745)](https://github.com/PennyLaneAI/pennylane/pull/4745)

* Operator and tape batch sizes are evaluated lazily, helping run expensive computations less frequently and an issue with Tensorflow pre-computing batch sizes. [(4911)](https://github.com/PennyLaneAI/pennylane/pull/4911)

<h4>Performance improvements and benchmarking</h4>

* Autograd, PyTorch, and JAX can now use vector-Jacobian products (VJPs) provided by the device from the new device API. If a device provides a VJP, this can be selected by providing `device_vjp=True` to a QNode or `qml.execute`. [(4935)](https://github.com/PennyLaneAI/pennylane/pull/4935) [(#4557)](https://github.com/PennyLaneAI/pennylane/pull/4557) [(#4654)](https://github.com/PennyLaneAI/pennylane/pull/4654) [(#4878)](https://github.com/PennyLaneAI/pennylane/pull/4878) [(#4841)](https://github.com/PennyLaneAI/pennylane/pull/4841)

pycon
>>> dev = qml.device('default.qubit')
>>> qml.qnode(dev, diff_method="adjoint", device_vjp=True)
>>> def circuit(x):
... qml.RX(x, wires=0)
... return qml.expval(qml.PauliZ(0))
>>> with dev.tracker:
... g = qml.grad(circuit)(qml.numpy.array(0.1))
>>> dev.tracker.totals
{'batches': 1, 'simulations': 1, 'executions': 1, 'vjp_batches': 1, 'vjps': 1}
>>> g
-0.09983341664682815


* `qml.expval` with large `Hamiltonian` objects is now faster and has a significantly lower memory footprint (and constant with respect to the number of `Hamiltonian` terms) when the `Hamiltonian` is a `PauliSentence`. This is due to the introduction of a specialized `dot` method in the `PauliSentence` class which performs `PauliSentence`-`state` products. [(4839)](https://github.com/PennyLaneAI/pennylane/pull/4839)

* `default.qubit` no longer uses a dense matrix for `MultiControlledX` for more than 8 operation wires. [(4673)](https://github.com/PennyLaneAI/pennylane/pull/4673)

* Some relevant Pytests have been updated to enable its use as a suite of benchmarks. [(4703)](https://github.com/PennyLaneAI/pennylane/pull/4703)

* `default.qubit` now applies `GroverOperator` faster by not using its matrix representation but a custom rule for `apply_operation`. Also, the matrix representation of `GroverOperator` now runs faster. [(4666)](https://github.com/PennyLaneAI/pennylane/pull/4666)

* A new pipeline to run benchmarks and plot graphs comparing with a fixed reference has been added. This pipeline will run on a schedule and can be activated on a PR with the label `ci:run_benchmarks`. [(4741)](https://github.com/PennyLaneAI/pennylane/pull/4741)

* `default.qubit` now supports adjoint differentiation for arbitrary diagonal state-based measurements. [(4865)](https://github.com/PennyLaneAI/pennylane/pull/4865)

* The benchmarks pipeline has been expanded to export all benchmark data to a single JSON file and a CSV file with runtimes. This includes all references and local benchmarks. [(4873)](https://github.com/PennyLaneAI/pennylane/pull/4873)

<h4>Final phase of updates to transforms</h4>

* `qml.quantum_monte_carlo` and `qml.simplify` now use the new transform system. [(4708)](https://github.com/PennyLaneAI/pennylane/pull/4708/) [(#4949)](https://github.com/PennyLaneAI/pennylane/pull/4949)

* The formal requirement that type hinting be provided when using the `qml.transform` decorator has been removed. Type hinting can still be used, but is now optional. Please use a type checker such as [mypy](https://github.com/python/mypy) if you wish to ensure types are being passed correctly. [(#4942)](https://github.com/PennyLaneAI/pennylane/pull/4942/)

<h4>Other improvements</h4>

* PennyLane now supports Python 3.12. [(4985)](https://github.com/PennyLaneAI/pennylane/pull/4985)

* `SampleMeasurement` now has an optional method `process_counts` for computing the measurement results from a counts dictionary. [(4941)](https://github.com/PennyLaneAI/pennylane/pull/4941/)

* A new function called `ops.functions.assert_valid` has been added for checking if an `Operator` class is defined correctly. [(4764)](https://github.com/PennyLaneAI/pennylane/pull/4764)

* `Shots` objects can now be multiplied by scalar values. [(4913)](https://github.com/PennyLaneAI/pennylane/pull/4913)

* `GlobalPhase` now decomposes to nothing in case devices do not support global phases. [(4855)](https://github.com/PennyLaneAI/pennylane/pull/4855)

* Custom operations can now provide their matrix directly through the `Operator.matrix()` method without needing to update the `has_matrix` property. `has_matrix` will now automatically be `True` if `Operator.matrix` is overridden, even if `Operator.compute_matrix` is not. [(4844)](https://github.com/PennyLaneAI/pennylane/pull/4844)

* The logic for re-arranging states before returning them has been improved. [(4817)](https://github.com/PennyLaneAI/pennylane/pull/4817)

* When multiplying `SparseHamiltonian`s by a scalar value, the result now stays as a `SparseHamiltonian`. [(4828)](https://github.com/PennyLaneAI/pennylane/pull/4828)

* `trainable_params` can now be set upon initialization of a `QuantumScript` instead of having to set the parameter after initialization. [(4877)](https://github.com/PennyLaneAI/pennylane/pull/4877)

* `default.qubit` now calculates the expectation value of `Hermitian` operators in a differentiable manner. [(4866)](https://github.com/PennyLaneAI/pennylane/pull/4866)

* The `rot` decomposition now has support for returning a global phase. [(4869)](https://github.com/PennyLaneAI/pennylane/pull/4869)

* The `"pennylane_sketch"` MPL-drawer style has been added. This is the same as the `"pennylane"` style, but with sketch-style lines. [(4880)](https://github.com/PennyLaneAI/pennylane/pull/4880)

* Operators now define a `pauli_rep` property, an instance of `PauliSentence`, defaulting to `None` if the operator has not defined it (or has no definition in the Pauli basis). [(4915)](https://github.com/PennyLaneAI/pennylane/pull/4915)

* `qml.ShotAdaptiveOptimizer` can now use a multinomial distribution for spreading shots across the terms of a Hamiltonian measured in a QNode. Note that this is equivalent to what can be done with `qml.ExpvalCost`, but this is the preferred method because `ExpvalCost` is deprecated. [(4896)](https://github.com/PennyLaneAI/pennylane/pull/4896)

* Decomposition of `qml.PhaseShift` now uses `qml.GlobalPhase` for retaining the global phase information. [(4657)](https://github.com/PennyLaneAI/pennylane/pull/4657) [(#4947)](https://github.com/PennyLaneAI/pennylane/pull/4947)

* `qml.equal` for `Controlled` operators no longer returns `False` when equivalent but differently-ordered sets of control wires and control values are compared. [(4944)](https://github.com/PennyLaneAI/pennylane/pull/4944)

* All PennyLane `Operator` subclasses are automatically tested by `ops.functions.assert_valid` to ensure that they follow PennyLane `Operator` standards. [(4922)](https://github.com/PennyLaneAI/pennylane/pull/4922)

* Probability measurements can now be calculated from a `counts` dictionary with the addition of a `process_counts` method in the `ProbabilityMP` class. [(4952)](https://github.com/PennyLaneAI/pennylane/pull/4952)

* `ClassicalShadow.entropy` now uses the algorithm outlined in [1106.5458](https://arxiv.org/abs/1106.5458) to project the approximate density matrix (with potentially negative eigenvalues) onto the closest valid density matrix. [(#4959)](https://github.com/PennyLaneAI/pennylane/pull/4959)

* The `ControlledSequence.compute_decomposition` default now decomposes the `Pow` operators, improving compatibility with machine learning interfaces. [(4995)](https://github.com/PennyLaneAI/pennylane/pull/4995)

<h3>Breaking changes 💔</h3>

* The functions `qml.transforms.one_qubit_decomposition`, `qml.transforms.two_qubit_decomposition`, and `qml.transforms.sk_decomposition` were moved to `qml.ops.one_qubit_decomposition`, `qml.ops.two_qubit_decomposition`, and `qml.ops.sk_decomposition`, respectively. [(4906)](https://github.com/PennyLaneAI/pennylane/pull/4906)

* The function `qml.transforms.classical_jacobian` has been moved to the gradients module and is now accessible as `qml.gradients.classical_jacobian`. [(4900)](https://github.com/PennyLaneAI/pennylane/pull/4900)

* The transforms submodule `qml.transforms.qcut` is now its own module: `qml.qcut`. [(4819)](https://github.com/PennyLaneAI/pennylane/pull/4819)

* The decomposition of `GroverOperator` now has an additional global phase operation. [(4666)](https://github.com/PennyLaneAI/pennylane/pull/4666)

* `qml.cond` and the `Conditional` operation have been moved from the `transforms` folder to the `ops/op_math` folder. `qml.transforms.Conditional` will now be available as `qml.ops.Conditional`. [(4860)](https://github.com/PennyLaneAI/pennylane/pull/4860)

* The `prep` keyword argument has been removed from `QuantumScript` and `QuantumTape`. `StatePrepBase` operations should be placed at the beginning of the `ops` list instead. [(4756)](https://github.com/PennyLaneAI/pennylane/pull/4756)

* `qml.gradients.pulse_generator` is now named `qml.gradients.pulse_odegen` to adhere to paper naming conventions. [(4769)](https://github.com/PennyLaneAI/pennylane/pull/4769)

* Specifying `control_values` passed to `qml.ctrl` as a string is no longer supported. [(4816)](https://github.com/PennyLaneAI/pennylane/pull/4816)

* The `rot` decomposition will now normalize its rotation angles to the range `[0, 4pi]` for consistency [(4869)](https://github.com/PennyLaneAI/pennylane/pull/4869)

* `QuantumScript.graph` is now built using `tape.measurements` instead of `tape.observables` because it depended on the now-deprecated `Observable.return_type` property. [(4762)](https://github.com/PennyLaneAI/pennylane/pull/4762)

* The `"pennylane"` MPL-drawer style now draws straight lines instead of sketch-style lines. [(4880)](https://github.com/PennyLaneAI/pennylane/pull/4880)

* The default value for the `term_sampling` argument of `ShotAdaptiveOptimizer` is now `None` instead of `"weighted_random_sampling"`. [(4896)](https://github.com/PennyLaneAI/pennylane/pull/4896)

<h3>Deprecations 👋</h3>

* `single_tape_transform`, `batch_transform`, `qfunc_transform`, and `op_transform` are deprecated. Use the new `qml.transform` function instead. [(4774)](https://github.com/PennyLaneAI/pennylane/pull/4774)

* `Observable.return_type` is deprecated. Instead, you should inspect the type of the surrounding measurement process. [(4762)](https://github.com/PennyLaneAI/pennylane/pull/4762) [(#4798)](https://github.com/PennyLaneAI/pennylane/pull/4798)

* All deprecations now raise a `qml.PennyLaneDeprecationWarning` instead of a `UserWarning`. [(4814)](https://github.com/PennyLaneAI/pennylane/pull/4814)

* `QuantumScript.is_sampled` and `QuantumScript.all_sampled` are deprecated. Users should now validate these properties manually. [(4773)](https://github.com/PennyLaneAI/pennylane/pull/4773)

* With an algorithmic improvement to `ClassicalShadow.entropy`, the keyword `atol` becomes obsolete and will be removed in v0.35. [(4959)](https://github.com/PennyLaneAI/pennylane/pull/4959)

<h3>Documentation 📝</h3>

* Documentation for unitaries and operations' decompositions has been moved from `qml.transforms` to `qml.ops.ops_math`. [(4906)](https://github.com/PennyLaneAI/pennylane/pull/4906)

* Documentation for `qml.metric_tensor` and `qml.adjoint_metric_tensor` and `qml.transforms.classical_jacobian` is now accessible via the gradients API page `qml.gradients` in the documentation. [(4900)](https://github.com/PennyLaneAI/pennylane/pull/4900)

* Documentation for `qml.specs` has been moved to the `resource` module. [(4904)](https://github.com/PennyLaneAI/pennylane/pull/4904)

* Documentation for QCut has been moved to its own API page: `qml.qcut`. [(4819)](https://github.com/PennyLaneAI/pennylane/pull/4819)

* The documentation page for `qml.measurements` now links top-level accessible functions (e.g., `qml.expval`) to their top-level pages rather than their module-level pages (e.g., `qml.measurements.expval`). [(4750)](https://github.com/PennyLaneAI/pennylane/pull/4750)

* Information for the documentation of `qml.matrix` about wire ordering has been added for using `qml.matrix` on a QNode which uses a device with `device.wires=None`. [(4874)](https://github.com/PennyLaneAI/pennylane/pull/4874)

<h3>Bug fixes 🐛</h3>

* `TransformDispatcher` now stops queuing when performing the transform when applying it to a qfunc. Only the output of the transform will be queued. [(4983)](https://github.com/PennyLaneAI/pennylane/pull/4983)

* `qml.map_wires` now works properly with `qml.cond` and `qml.measure`. [(4884)](https://github.com/PennyLaneAI/pennylane/pull/4884)

* `Pow` operators are now picklable. [(4966)](https://github.com/PennyLaneAI/pennylane/pull/4966)

* Finite differences and SPSA can now be used with tensorflow-autograph on setups that were seeing a bus error. [(4961)](https://github.com/PennyLaneAI/pennylane/pull/4961)

* `qml.cond` no longer incorrectly queues operators used arguments. [(4948)](https://github.com/PennyLaneAI/pennylane/pull/4948)

* `Attribute` objects now return `False` instead of raising a `TypeError` when checking if an object is inside the set. [(4933)](https://github.com/PennyLaneAI/pennylane/pull/4933)

* Fixed a bug where the parameter-shift rule of `qml.ctrl(op)` was wrong if `op` had a generator that has two or more eigenvalues and is stored as a `SparseHamiltonian`. [(4899)](https://github.com/PennyLaneAI/pennylane/pull/4899)

* Fixed a bug where trainable parameters in the post-processing of finite-differences were incorrect for JAX when applying the transform directly on a QNode. [(4879)](https://github.com/PennyLaneAI/pennylane/pull/4879)

* `qml.grad` and `qml.jacobian` now explicitly raise errors if trainable parameters are integers. [(4836)](https://github.com/PennyLaneAI/pennylane/pull/4836)

* JAX-JIT now works with shot vectors. [(4772)](https://github.com/PennyLaneAI/pennylane/pull/4772/)

* JAX can now differentiate a batch of circuits where one tape does not have trainable parameters. [(4837)](https://github.com/PennyLaneAI/pennylane/pull/4837)

* The decomposition of `GroverOperator` now has the same global phase as its matrix. [(4666)](https://github.com/PennyLaneAI/pennylane/pull/4666)

* The `tape.to_openqasm` method no longer mistakenly includes interface information in the parameter string when converting tapes using non-NumPy interfaces. [(4849)](https://github.com/PennyLaneAI/pennylane/pull/4849)

* `qml.defer_measurements` now correctly transforms circuits when terminal measurements include wires used in mid-circuit measurements. [(4787)](https://github.com/PennyLaneAI/pennylane/pull/4787)

* Fixed a bug where the adjoint differentiation method would fail if an operation that has a parameter with `grad_method=None` is present. [(4820)](https://github.com/PennyLaneAI/pennylane/pull/4820)

* `MottonenStatePreparation` and `BasisStatePreparation` now raise an error when decomposing a broadcasted state vector. [(4767)](https://github.com/PennyLaneAI/pennylane/pull/4767)

* Gradient transforms now work with overridden shot vectors and `default.qubit`. [(4795)](https://github.com/PennyLaneAI/pennylane/pull/4795)

* Any `ScalarSymbolicOp`, like `Evolution`, now states that it has a matrix if the target is a `Hamiltonian`. [(4768)](https://github.com/PennyLaneAI/pennylane/pull/4768)

* In `default.qubit`, initial states are now initialized with the simulator's wire order, not the circuit's wire order. [(4781)](https://github.com/PennyLaneAI/pennylane/pull/4781)

* `qml.compile` will now always decompose to `expand_depth`, even if a target basis set is not specified. [(4800)](https://github.com/PennyLaneAI/pennylane/pull/4800)

* `qml.transforms.transpile` can now handle measurements that are broadcasted onto all wires. [(4793)](https://github.com/PennyLaneAI/pennylane/pull/4793)

* Parametrized circuits whose operators do not act on all wires return PennyLane tensors instead of NumPy arrays, as expected. [(4811)](https://github.com/PennyLaneAI/pennylane/pull/4811) [(#4817)](https://github.com/PennyLaneAI/pennylane/pull/4817)

* `qml.transforms.merge_amplitude_embedding` no longer depends on queuing, allowing it to work as expected with QNodes. [(4831)](https://github.com/PennyLaneAI/pennylane/pull/4831)

* `qml.pow(op)` and `qml.QubitUnitary.pow()` now also work with Tensorflow data raised to an integer power. [(4827)](https://github.com/PennyLaneAI/pennylane/pull/4827)

* The text drawer has been fixed to correctly label `qml.qinfo` measurements, as well as `qml.classical_shadow` `qml.shadow_expval`. [(4803)](https://github.com/PennyLaneAI/pennylane/pull/4803)

* Removed an implicit assumption that an empty `PauliSentence` gets treated as identity under multiplication. [(4887)](https://github.com/PennyLaneAI/pennylane/pull/4887)

* Using a `CNOT` or `PauliZ` operation with large batched states and the Tensorflow interface no longer raises an unexpected error. [(4889)](https://github.com/PennyLaneAI/pennylane/pull/4889)

* `qml.map_wires` no longer fails when mapping nested quantum tapes. [(4901)](https://github.com/PennyLaneAI/pennylane/pull/4901)

* Conversion of circuits to openqasm now decomposes to a depth of 10, allowing support for operators requiring more than 2 iterations of decomposition, such as the `ApproxTimeEvolution` gate. [(4951)](https://github.com/PennyLaneAI/pennylane/pull/4951)

* `MPLDrawer` does not add the bonus space for classical wires when no classical wires are present. [(4987)](https://github.com/PennyLaneAI/pennylane/pull/4987)

* `Projector` now works with parameter-broadcasting. [(4993)](https://github.com/PennyLaneAI/pennylane/pull/4993) * The jax-jit interface can now be used with float32 mode. [(#4990)](https://github.com/PennyLaneAI/pennylane/pull/4990)

* Keras models with a `qnn.KerasLayer` no longer fail to save and load weights properly when they are named "weights". [(5008)](https://github.com/PennyLaneAI/pennylane/pull/5008)

<h3>Contributors ✍️</h3>

This release contains contributions from (in alphabetical order):

Guillermo Alonso, Ali Asadi, Utkarsh Azad, Gabriel Bottrill, Thomas Bromley, Astral Cai, Minh Chau, Isaac De Vlugt, Amintor Dusko, Pieter Eendebak, Lillian Frederiksen, Pietropaolo Frisoni, Josh Izaac, Juan Giraldo, Emiliano Godinez Ramirez, Ankit Khandelwal, Korbinian Kottmann, Christina Lee, Vincent Michaud-Rioux, Anurav Modak, Romain Moyard, Mudit Pandey, Matthew Silverman, Jay Soni, David Wierichs, Justin Woodring.

<h3>Bug fixes 🐛</h3>

* Fix gradient performance regression due to expansion of VJP products. [(4806)](https://github.com/PennyLaneAI/pennylane/pull/4806)

* `qml.defer_measurements` now correctly transforms circuits when terminal measurements include wires used in mid-circuit measurements. [(4787)](https://github.com/PennyLaneAI/pennylane/pull/4787)

* Any `ScalarSymbolicOp`, like `Evolution`, now states that it has a matrix if the target is a `Hamiltonian`. [(4768)](https://github.com/PennyLaneAI/pennylane/pull/4768)

* In `default.qubit`, initial states are now initialized with the simulator's wire order, not the circuit's wire order. [(4781)](https://github.com/PennyLaneAI/pennylane/pull/4781)

<h3>Contributors ✍️</h3>

This release contains contributions from (in alphabetical order):

Christina Lee, Lee James O'Riordan, Mudit Pandey

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

<h4>Postselection and statistics in mid-circuit measurements 📌</h4>

* It is now possible to request postselection on a mid-circuit measurement. [(4604)](https://github.com/PennyLaneAI/pennylane/pull/4604)

This can be achieved by specifying the `postselect` keyword argument in `qml.measure` as either `0` or `1`, corresponding to the basis states.

python
import pennylane as qml

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

qml.qnode(dev, interface=None)
def circuit():
qml.Hadamard(wires=0)
qml.CNOT(wires=[0, 1])
qml.measure(0, postselect=1)
return qml.expval(qml.PauliZ(1)), qml.sample(wires=1)

This circuit prepares the $| \Phi^{+} \rangle$ Bell state and postselects on measuring $|1\rangle$ in wire `0`. The output of wire `1` is then also $|1\rangle$ at all times:

pycon
>>> circuit(shots=10)
(-1.0, array([1, 1, 1, 1, 1, 1]))

Note that the number of shots is less than the requested amount because we have thrown away the samples where $|0\rangle$ was measured in wire `0`.

* Measurement statistics can now be collected for mid-circuit measurements. [(4544)](https://github.com/PennyLaneAI/pennylane/pull/4544)

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

qml.qnode(dev)
def circ(x, y):
qml.RX(x, wires=0)
qml.RY(y, wires=1)
m0 = qml.measure(1)
return qml.expval(qml.PauliZ(0)), qml.expval(m0), qml.sample(m0)


pycon
>>> circ(1.0, 2.0, shots=10000)
(0.5606, 0.7089, array([0, 1, 1, ..., 1, 1, 1]))

Support is provided for both [finite-shot and analytic modes](https://docs.pennylane.ai/en/stable/introduction/circuits.html#shots) and devices default to using the [deferred measurement](https://docs.pennylane.ai/en/stable/code/api/pennylane.defer_measurements.html) principle to enact the mid-circuit measurements.

<h4>Exponentiate Hamiltonians with flexible Trotter products 🐖</h4>

* Higher-order Trotter-Suzuki methods are now easily accessible through a new operation called `TrotterProduct`. [(4661)](https://github.com/PennyLaneAI/pennylane/pull/4661)

Trotterization techniques are an affective route towards accurate and efficient Hamiltonian simulation. The Suzuki-Trotter product formula allows for the ability to express higher-order approximations to the matrix exponential of a Hamiltonian, and it is now available to use in PennyLane via the `TrotterProduct` operation. Simply specify the `order` of the approximation and the evolution `time`.

python
coeffs = [0.25, 0.75]
ops = [qml.PauliX(0), qml.PauliZ(0)]
H = qml.dot(coeffs, ops)

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

qml.qnode(dev)
def circuit():
qml.Hadamard(0)
qml.TrotterProduct(H, time=2.4, order=2)
return qml.state()


pycon
>>> circuit()
[-0.13259524+0.59790098j 0. +0.j -0.13259524-0.77932754j 0. +0.j ]


* Approximating matrix exponentiation with random product formulas, qDrift, is now available with the new `QDrift` operation. [(4671)](https://github.com/PennyLaneAI/pennylane/pull/4671)

As shown in [1811.08017](https://arxiv.org/pdf/1811.08017.pdf), qDrift is a Markovian process that can provide a speedup in Hamiltonian simulation. At a high level, qDrift works by randomly sampling from the Hamiltonian terms with a probability that depends on the Hamiltonian coefficients. This method for Hamiltonian simulation is now ready to use in PennyLane with the `QDrift` operator. Simply specify the evolution `time` and the number of samples drawn from the Hamiltonian, `n`:
python
coeffs = [0.25, 0.75]
ops = [qml.PauliX(0), qml.PauliZ(0)]
H = qml.dot(coeffs, ops)

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

qml.qnode(dev)
def circuit():
qml.Hadamard(0)
qml.QDrift(H, time=1.2, n = 10)
return qml.probs()


pycon
>>> circuit()
array([0.61814334, 0. , 0.38185666, 0. ])


<h4>Building blocks for quantum phase estimation 🧱</h4>

* A new operator called `CosineWindow` has been added to prepare an initial state based on a cosine wave function. [(4683)](https://github.com/PennyLaneAI/pennylane/pull/4683)

As outlined in [2110.09590](https://arxiv.org/pdf/2110.09590.pdf), the cosine tapering window is part of a modification to quantum phase estimation that can provide a cubic improvement to the algorithm's error rate. Using `CosineWindow` will prepare a state whose amplitudes follow a cosinusoidal distribution over the computational basis.

python
import matplotlib.pyplot as plt

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

qml.qnode(dev)
def example_circuit():
qml.CosineWindow(wires=range(4))
return qml.state()

output = example_circuit()

plt.style.use("pennylane.drawer.plot")
plt.bar(range(len(output)), output)
plt.show()


<img src="https://docs.pennylane.ai/en/stable/_images/cosine_window.png" width=50%/>

* Controlled gate sequences raised to decreasing powers, a sub-block in quantum phase estimation, can now be created with the new `ControlledSequence` operator. [(4707)](https://github.com/PennyLaneAI/pennylane/pull/4707/)

To use `ControlledSequence`, specify the controlled unitary operator and the control wires, `control`:

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

qml.qnode(dev)
def circuit():
for i in range(3):
qml.Hadamard(wires = i)
qml.ControlledSequence(qml.RX(0.25, wires = 3), control = [0, 1, 2])
qml.adjoint(qml.QFT)(wires = range(3))
return qml.probs(wires = range(3))


pycon
>>> print(circuit())
[0.92059345 0.02637178 0.00729619 0.00423258 0.00360545 0.00423258 0.00729619 0.02637178]


<h4>New device capabilities, integration with Catalyst, and more! ⚗️</h4>

* `default.qubit` now uses the new `qml.devices.Device` API and functionality in `qml.devices.qubit`. If you experience any issues with the updated `default.qubit`, please let us know by [posting an issue](https://github.com/PennyLaneAI/pennylane/issues/new/choose). The old version of the device is still accessible by the short name `default.qubit.legacy`, or directly via `qml.devices.DefaultQubitLegacy`. [(#4594)](https://github.com/PennyLaneAI/pennylane/pull/4594) [(#4436)](https://github.com/PennyLaneAI/pennylane/pull/4436) [(#4620)](https://github.com/PennyLaneAI/pennylane/pull/4620) [(#4632)](https://github.com/PennyLaneAI/pennylane/pull/4632)

This changeover has a number of benefits for `default.qubit`, including:

* The number of wires is now optional — simply having `qml.device("default.qubit")` is valid! If wires are not provided at instantiation, the device automatically infers the required number of wires for each circuit provided for execution.

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

qml.qnode(dev)
def circuit():
qml.PauliZ(0)
qml.RZ(0.1, wires=1)
qml.Hadamard(2)
return qml.state()


pycon
>>> print(qml.draw(circuit)())
0: ──Z────────┤ State
1: ──RZ(0.10)─┤ State
2: ──H────────┤ State


* `default.qubit` is no longer silently swapped out with an interface-appropriate device when the backpropagation differentiation method is used. For example, consider:

python
import jax

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

qml.qnode(dev, diff_method="backprop")
def f(x):
qml.RX(x, wires=0)
return qml.expval(qml.PauliZ(0))
f(jax.numpy.array(0.2))

In previous versions of PennyLane, the device will be swapped for the JAX equivalent:

pycon
>>> f.device
<DefaultQubitJax device (wires=1, shots=None) at 0x7f8c8bff50a0>
>>> f.device == dev
False

Now, `default.qubit` can itself dispatch to all the interfaces in a backprop-compatible way and hence does not need to be swapped:

pycon
>>> f.device
<default.qubit device (wires=1) at 0x7f20d043b040>
>>> f.device == dev
True


* A QNode that has been decorated with `qjit` from PennyLane's [Catalyst](https://docs.pennylane.ai/projects/catalyst) library for just-in-time hybrid compilation is now compatible with `qml.draw`. [(#4609)](https://github.com/PennyLaneAI/pennylane/pull/4609)

python
import catalyst

catalyst.qjit
qml.qnode(qml.device("lightning.qubit", wires=3))
def circuit(x, y, z, c):
"""A quantum circuit on three wires."""

catalyst.for_loop(0, c, 1)
def loop(i):
qml.Hadamard(wires=i)

qml.RX(x, wires=0)
loop()
qml.RY(y, wires=1)
qml.RZ(z, wires=2)
return qml.expval(qml.PauliZ(0))

draw = qml.draw(circuit, decimals=None)(1.234, 2.345, 3.456, 1)

pycon
>>> print(draw)
0: ──RX──H──┤ <Z>
1: ──H───RY─┤
2: ──RZ─────┤


<h3>Improvements 🛠</h3>

<h4>More PyTrees!</h4>

* `MeasurementProcess` and `QuantumScript` objects are now registered as JAX PyTrees. [(4607)](https://github.com/PennyLaneAI/pennylane/pull/4607) [(#4608)](https://github.com/PennyLaneAI/pennylane/pull/4608)

It is now possible to JIT-compile functions with arguments that are a `MeasurementProcess` or a `QuantumScript`:

python import jax

tape0 = qml.tape.QuantumTape([qml.RX(1.0, 0), qml.RY(0.5, 0)], [qml.expval(qml.PauliZ(0))])
dev = qml.device('lightning.qubit', wires=5)

execute_kwargs = {"device": dev, "gradient_fn": qml.gradients.param_shift, "interface":"jax"}

jitted_execute = jax.jit(qml.execute, static_argnames=execute_kwargs.keys())
jitted_execute((tape0, ), **execute_kwargs)


<h4>Improving QChem and existing algorithms</h4>

* Computationally expensive functions in `integrals.py`, `electron_repulsion` and `_hermite_coulomb`, have been modified to replace indexing with slicing for better compatibility with JAX. [(4685)](https://github.com/PennyLaneAI/pennylane/pull/4685)

* `qml.qchem.import_state` has been extended to import more quantum chemistry wavefunctions, from MPS, DMRG and SHCI classical calculations performed with the Block2 and Dice libraries. [4523](https://github.com/PennyLaneAI/pennylane/pull/4523) [#4524](https://github.com/PennyLaneAI/pennylane/pull/4524) [#4626](https://github.com/PennyLaneAI/pennylane/pull/4626) [#4634](https://github.com/PennyLaneAI/pennylane/pull/4634)

Check out our [how-to guide](https://pennylane.ai/qml/demos/tutorial_initial_state_preparation) to learn more about how PennyLane integrates with your favourite quantum chemistry libraries.

* The qchem `fermionic_dipole` and `particle_number` functions have been updated to use a `FermiSentence`. The deprecated features for using tuples to represent fermionic operations are removed. [(4546)](https://github.com/PennyLaneAI/pennylane/pull/4546) [(#4556)](https://github.com/PennyLaneAI/pennylane/pull/4556)

* The tensor-network template `qml.MPS` now supports changing the `offset` between subsequent blocks for more flexibility. [(4531)](https://github.com/PennyLaneAI/pennylane/pull/4531)

* Builtin types support with `qml.pauli_decompose` have been improved. [(4577)](https://github.com/PennyLaneAI/pennylane/pull/4577)

* `AmplitudeEmbedding` now inherits from `StatePrep`, allowing for it to not be decomposed when at the beginning of a circuit, thus behaving like `StatePrep`. [(4583)](https://github.com/PennyLaneAI/pennylane/pull/4583)

* `qml.cut_circuit` is now compatible with circuits that compute the expectation values of Hamiltonians with two or more terms. [(4642)](https://github.com/PennyLaneAI/pennylane/pull/4642)

<h4>Next-generation device API</h4>

* `default.qubit` now tracks the number of equivalent qpu executions and total shots when the device is sampling. Note that `"simulations"` denotes the number of simulation passes, whereas `"executions"` denotes how many different computational bases need to be sampled in. Additionally, the new `default.qubit` tracks the results of `device.execute`. [(4628)](https://github.com/PennyLaneAI/pennylane/pull/4628) [(#4649)](https://github.com/PennyLaneAI/pennylane/pull/4649)

* `DefaultQubit` can now accept a `jax.random.PRNGKey` as a `seed` to set the key for the JAX pseudo random number generator when using the JAX interface. This corresponds to the `prng_key` on `default.qubit.jax` in the old API. [(4596)](https://github.com/PennyLaneAI/pennylane/pull/4596)

* The `JacobianProductCalculator` abstract base class and implementations `TransformJacobianProducts` `DeviceDerivatives`, and `DeviceJacobianProducts` have been added to `pennylane.interfaces.jacobian_products`. [(4435)](https://github.com/PennyLaneAI/pennylane/pull/4435) [(#4527)](https://github.com/PennyLaneAI/pennylane/pull/4527) [(#4637)](https://github.com/PennyLaneAI/pennylane/pull/4637)

* `DefaultQubit` dispatches to a faster implementation for applying `ParametrizedEvolution` to a state when it is more efficient to evolve the state than the operation matrix. [(4598)](https://github.com/PennyLaneAI/pennylane/pull/4598) [(#4620)](https://github.com/PennyLaneAI/pennylane/pull/4620)

* Wires can be provided to the new device API. [(4538)](https://github.com/PennyLaneAI/pennylane/pull/4538) [(#4562)](https://github.com/PennyLaneAI/pennylane/pull/4562)

* `qml.sample()` in the new device API now returns a `np.int64` array instead of `np.bool8`. [(4539)](https://github.com/PennyLaneAI/pennylane/pull/4539)

* The new device API now has a `repr()` method. [(4562)](https://github.com/PennyLaneAI/pennylane/pull/4562)

* `DefaultQubit` now works as expected with measurement processes that don't specify wires. [(4580)](https://github.com/PennyLaneAI/pennylane/pull/4580)

* Various improvements to measurements have been made for feature parity between `default.qubit.legacy` and the new `DefaultQubit`. This includes not trying to squeeze batched `CountsMP` results and implementing `MutualInfoMP.map_wires`. [(4574)](https://github.com/PennyLaneAI/pennylane/pull/4574)

* `devices.qubit.simulate` now accepts an interface keyword argument. If a QNode with `DefaultQubit` specifies an interface, the result will be computed with that interface. [(4582)](https://github.com/PennyLaneAI/pennylane/pull/4582)

* `ShotAdaptiveOptimizer` has been updated to pass shots to QNode executions instead of overriding device shots before execution. This makes it compatible with the new device API. [(4599)](https://github.com/PennyLaneAI/pennylane/pull/4599)

* `pennylane.devices.preprocess` now offers the transforms `decompose`, `validate_observables`, `validate_measurements`, `validate_device_wires`, `validate_multiprocessing_workers`, `warn_about_trainable_observables`, and `no_sampling` to assist in constructing devices under the new device API. [(4659)](https://github.com/PennyLaneAI/pennylane/pull/4659)

* Updated `qml.device`, `devices.preprocessing` and the `tape_expand.set_decomposition` context manager to bring `DefaultQubit` to feature parity with `default.qubit.legacy` with regards to using custom decompositions. The `DefaultQubit` device can now be included in a `set_decomposition` context or initialized with a `custom_decomps` dictionary, as well as a custom `max_depth` for decomposition. [(4675)](https://github.com/PennyLaneAI/pennylane/pull/4675)

<h4>Other improvements</h4>

* The `StateMP` measurement now accepts a wire order (e.g., a device wire order). The `process_state` method will re-order the given state to go from the inputted wire-order to the process's wire-order. If the process's wire-order contains extra wires, it will assume those are in the zero-state. [(4570)](https://github.com/PennyLaneAI/pennylane/pull/4570) [(#4602)](https://github.com/PennyLaneAI/pennylane/pull/4602)

* Methods called `add_transform` and `insert_front_transform` have been added to `TransformProgram`. [(4559)](https://github.com/PennyLaneAI/pennylane/pull/4559)

* Instances of the `TransformProgram` class can now be added together. [(4549)](https://github.com/PennyLaneAI/pennylane/pull/4549)

* Transforms can now be applied to devices following the new device API. [(4667)](https://github.com/PennyLaneAI/pennylane/pull/4667)

* All gradient transforms have been updated to the new transform program system. [(4595)](https://github.com/PennyLaneAI/pennylane/pull/4595)

* Multi-controlled operations with a single-qubit special unitary target can now automatically decompose. [(4697)](https://github.com/PennyLaneAI/pennylane/pull/4697)

* `pennylane.defer_measurements` will now exit early if the input does not contain mid circuit measurements. [(4659)](https://github.com/PennyLaneAI/pennylane/pull/4659)

* The density matrix aspects of `StateMP` have been split into their own measurement process called `DensityMatrixMP`. [(4558)](https://github.com/PennyLaneAI/pennylane/pull/4558)

* `StateMeasurement.process_state` now assumes that the input is flat. `ProbabilityMP.process_state` has been updated to reflect this assumption and avoid redundant reshaping. [(4602)](https://github.com/PennyLaneAI/pennylane/pull/4602)

* `qml.exp` returns a more informative error message when decomposition is unavailable for non-unitary operators. [(4571)](https://github.com/PennyLaneAI/pennylane/pull/4571)

* Added `qml.math.get_deep_interface` to get the interface of a scalar hidden deep in lists or tuples. [(4603)](https://github.com/PennyLaneAI/pennylane/pull/4603)

* Updated `qml.math.ndim` and `qml.math.shape` to work with built-in lists or tuples that contain interface-specific scalar dat (e.g., `[(tf.Variable(1.1), tf.Variable(2.2))]`). [(4603)](https://github.com/PennyLaneAI/pennylane/pull/4603)

* When decomposing a unitary matrix with `one_qubit_decomposition` and opting to include the `GlobalPhase` in the decomposition, the phase is no longer cast to `dtype=complex`. [(4653)](https://github.com/PennyLaneAI/pennylane/pull/4653)

* `_qfunc_output` has been removed from `QuantumScript`, as it is no longer necessary. There is still a `_qfunc_output` property on `QNode` instances. [(4651)](https://github.com/PennyLaneAI/pennylane/pull/4651)

* `qml.data.load` properly handles parameters that come after `'full'` [(4663)](https://github.com/PennyLaneAI/pennylane/pull/4663)

* The `qml.jordan_wigner` function has been modified to optionally remove the imaginary components of the computed qubit operator, if imaginary components are smaller than a threshold. [(4639)](https://github.com/PennyLaneAI/pennylane/pull/4639)

* `qml.data.load` correctly performs a full download of the dataset after a partial download of the same dataset has already been performed. [(4681)](https://github.com/PennyLaneAI/pennylane/pull/4681) * The performance of `qml.data.load()` has been improved when partially loading a dataset [(#4674)](https://github.com/PennyLaneAI/pennylane/pull/4674)

* Plots generated with the `pennylane.drawer.plot` style of `matplotlib.pyplot` now have black axis labels and are generated at a default DPI of 300. [(4690)](https://github.com/PennyLaneAI/pennylane/pull/4690)

* Shallow copies of the `QNode` now also copy the `execute_kwargs` and transform program. When applying a transform to a `QNode`, the new qnode is only a shallow copy of the original and thus keeps the same device. [(4736)](https://github.com/PennyLaneAI/pennylane/pull/4736)

* `QubitDevice` and `CountsMP` are updated to disregard samples containing failed hardware measurements (record as `np.NaN`) when tallying samples, rather than counting failed measurements as ground-state measurements, and to display `qml.counts` coming from these hardware devices correctly. [(4739)](https://github.com/PennyLaneAI/pennylane/pull/4739)

<h3>Breaking changes 💔</h3>

* `qml.defer_measurements` now raises an error if a transformed circuit measures `qml.probs`, `qml.sample`, or `qml.counts` without any wires or observable, or if it measures `qml.state`. [(4701)](https://github.com/PennyLaneAI/pennylane/pull/4701)

* The device test suite now converts device keyword arguments to integers or floats if possible. [(4640)](https://github.com/PennyLaneAI/pennylane/pull/4640)

* `MeasurementProcess.eigvals()` now raises an `EigvalsUndefinedError` if the measurement observable does not have eigenvalues. [(4544)](https://github.com/PennyLaneAI/pennylane/pull/4544)

* The `__eq__` and `__hash__` methods of `Operator` and `MeasurementProcess` no longer rely on the object's address in memory. Using `==` with operators and measurement processes will now behave the same as `qml.equal`, and objects of the same type with the same data and hyperparameters will have the same hash. [(4536)](https://github.com/PennyLaneAI/pennylane/pull/4536)

In the following scenario, the second and third code blocks show the previous and current behaviour of operator and measurement process equality, determined by `==`:

python
op1 = qml.PauliX(0)
op2 = qml.PauliX(0)
op3 = op1


Old behaviour:

pycon
>>> op1 == op2
False
>>> op1 == op3
True


New behaviour:

pycon
>>> op1 == op2
True
>>> op1 == op3
True


The `__hash__` dunder method defines the hash of an object. The default hash of an object is determined by the objects memory address. However, the new hash is determined by the properties and attributes of operators and measurement processes. Consider the scenario below. The second and third code blocks show the previous and current behaviour.

python
op1 = qml.PauliX(0)
op2 = qml.PauliX(0)


Old behaviour:

pycon
>>> print({op1, op2})
{PauliX(wires=[0]), PauliX(wires=[0])}


New behaviour:

pycon
>>> print({op1, op2})
{PauliX(wires=[0])}


* The old return type and associated functions `qml.enable_return` and `qml.disable_return` have been removed. [(4503)](https://github.com/PennyLaneAI/pennylane/pull/4503)

* The `mode` keyword argument in `QNode` has been removed. Please use `grad_on_execution` instead. [(4503)](https://github.com/PennyLaneAI/pennylane/pull/4503)

* The CV observables `qml.X` and `qml.P` have been removed. Please use `qml.QuadX` and `qml.QuadP` instead. [(4533)](https://github.com/PennyLaneAI/pennylane/pull/4533)

* The `sampler_seed` argument of `qml.gradients.spsa_grad` has been removed. Instead, the `sampler_rng` argument should be set, either to an integer value, which will be used to create a PRNG internally, or to a NumPy pseudo-random number generator (PRNG) created via `np.random.default_rng(seed)`. [(4550)](https://github.com/PennyLaneAI/pennylane/pull/4550)

* The `QuantumScript.set_parameters` method and the `QuantumScript.data` setter have been removed. Please use `QuantumScript.bind_new_parameters` instead. [(4548)](https://github.com/PennyLaneAI/pennylane/pull/4548)

* The method `tape.unwrap()` and corresponding `UnwrapTape` and `Unwrap` classes have been removed. Instead of `tape.unwrap()`, use `qml.transforms.convert_to_numpy_parameters`. [(4535)](https://github.com/PennyLaneAI/pennylane/pull/4535)

* The `RandomLayers.compute_decomposition` keyword argument `ratio_imprivitive` has been changed to `ratio_imprim` to match the call signature of the operation. [(4552)](https://github.com/PennyLaneAI/pennylane/pull/4552)

* The private `TmpPauliRot` operator used for `SpecialUnitary` no longer decomposes to nothing when the theta value is trainable. [(4585)](https://github.com/PennyLaneAI/pennylane/pull/4585)

* `ProbabilityMP.marginal_prob` has been removed. Its contents have been moved into `process_state`, which effectively just called `marginal_prob` with `np.abs(state) ** 2`. [(4602)](https://github.com/PennyLaneAI/pennylane/pull/4602)

<h3>Deprecations 👋</h3>

* The following decorator syntax for transforms has been deprecated and will raise a warning: [(4457)](https://github.com/PennyLaneAI/pennylane/pull/4457/)

python
transform_fn(**transform_kwargs)
qml.qnode(dev)
def circuit():
...

If you are using a transform that has supporting `transform_kwargs`, please call the transform directly using `circuit = transform_fn(circuit, **transform_kwargs)`, or use `functools.partial`:

python
functools.partial(transform_fn, **transform_kwargs)
qml.qnode(dev)
def circuit():
...


* The `prep` keyword argument in `QuantumScript` has been deprecated and will be removed from `QuantumScript`. `StatePrepBase` operations should be placed at the beginning of the `ops` list instead. [(4554)](https://github.com/PennyLaneAI/pennylane/pull/4554)

* `qml.gradients.pulse_generator` has been renamed to `qml.gradients.pulse_odegen` to adhere to paper naming conventions. During v0.33, `pulse_generator` is still available but raises a warning. [(4633)](https://github.com/PennyLaneAI/pennylane/pull/4633)

<h3>Documentation 📝</h3>

* A warning section in the docstring for `DefaultQubit` regarding the start method used in multiprocessing has been added. This may help users circumvent issues arising in Jupyter notebooks on macOS for example. [(4622)](https://github.com/PennyLaneAI/pennylane/pull/4622)

* Documentation improvements to the new device API have been made. The documentation now correctly states that interface-specific parameters are only passed to the device for backpropagation derivatives. [(4542)](https://github.com/PennyLaneAI/pennylane/pull/4542)

* Functions for qubit-simulation to the `qml.devices` sub-page of the "Internal" section have been added. Note that these functions are unstable while device upgrades are underway. [(4555)](https://github.com/PennyLaneAI/pennylane/pull/4555)

* A documentation improvement to the usage example in the `qml.QuantumMonteCarlo` page has been made. An integral was missing the differential $dx$. [(4593)](https://github.com/PennyLaneAI/pennylane/pull/4593)

* A documentation improvement for the use of the `pennylane` style of `qml.drawer` and the `pennylane.drawer.plot` style of `matplotlib.pyplot` has been made by clarifying the use of the default font. [(4690)](https://github.com/PennyLaneAI/pennylane/pull/4690)

<h3>Bug fixes 🐛</h3>

* Jax jit now works when a probability measurement is broadcasted onto all wires. [(4742)](https://github.com/PennyLaneAI/pennylane/pull/4742)

* Fixed `LocalHilbertSchmidt.compute_decomposition` so that the template can be used in a QNode. [(4719)](https://github.com/PennyLaneAI/pennylane/pull/4719)

* Fixes `transforms.transpile` with arbitrary measurement processes. [(4732)](https://github.com/PennyLaneAI/pennylane/pull/4732)

* Providing `work_wires=None` to `qml.GroverOperator` no longer interprets `None` as a wire. [(4668)](https://github.com/PennyLaneAI/pennylane/pull/4668)

* Fixed an issue where the `__copy__` method of the `qml.Select()` operator attempted to access un-initialized data. [(4551)](https://github.com/PennyLaneAI/pennylane/pull/4551)

* Fixed the `skip_first` option in `expand_tape_state_prep`. [(4564)](https://github.com/PennyLaneAI/pennylane/pull/4564)

* `convert_to_numpy_parameters` now uses `qml.ops.functions.bind_new_parameters`. This reinitializes the operation and makes sure everything references the new NumPy parameters. [(4540)](https://github.com/PennyLaneAI/pennylane/pull/4540)

* `tf.function` no longer breaks `ProbabilityMP.process_state`, which is needed by new devices. [(4470)](https://github.com/PennyLaneAI/pennylane/pull/4470)

* Fixed unit tests for `qml.qchem.mol_data`. [(4591)](https://github.com/PennyLaneAI/pennylane/pull/4591)

* Fixed `ProbabilityMP.process_state` so that it allows for proper Autograph compilation. Without this, decorating a QNode that returns an `expval` with `tf.function` would fail when computing the expectation. [(4590)](https://github.com/PennyLaneAI/pennylane/pull/4590)

* The `torch.nn.Module` properties are now accessible on a `pennylane.qnn.TorchLayer`. [(4611)](https://github.com/PennyLaneAI/pennylane/pull/4611)

* `qml.math.take` with Pytorch now returns `tensor[..., indices]` when the user requests the last axis (`axis=-1`). Without the fix, it would wrongly return `tensor[indices]`. [(4605)](https://github.com/PennyLaneAI/pennylane/pull/4605)

* Ensured the logging `TRACE` level works with gradient-free execution. [(4669)](https://github.com/PennyLaneAI/pennylane/pull/4669)

<h3>Contributors ✍️</h3>

This release contains contributions from (in alphabetical order):

Guillermo Alonso, Utkarsh Azad, Thomas Bromley, Isaac De Vlugt, Jack Brown, Stepan Fomichev, Joana Fraxanet, Diego Guala, Soran Jahangiri, Edward Jiang, Korbinian Kottmann, Ivana Kurečić Christina Lee, Lillian M. A. Frederiksen, Vincent Michaud-Rioux, Romain Moyard, Daniel F. Nino, Lee James O'Riordan, Mudit Pandey, Matthew Silverman, Jay Soni.

This release changes `doc/requirements.txt` to upgrade `jax`, `jaxlib`, and pin `ml-dtypes`.

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

<h4>Encode matrices using a linear combination of unitaries ⛓️️</h4>

* It is now possible to encode an operator `A` into a quantum circuit by decomposing it into a linear combination of unitaries using PREP ([qml.StatePrep](https://docs.pennylane.ai/en/stable/code/api/pennylane.StatePrep.html)) and SELECT ([qml.Select](https://docs.pennylane.ai/en/stable/code/api/pennylane.Select.html)) routines. [(#4431)](https://github.com/PennyLaneAI/pennylane/pull/4431) [(#4437)](https://github.com/PennyLaneAI/pennylane/pull/4437) [(#4444)](https://github.com/PennyLaneAI/pennylane/pull/4444) [(#4450)](https://github.com/PennyLaneAI/pennylane/pull/4450) [(#4506)](https://github.com/PennyLaneAI/pennylane/pull/4506) [(#4526)](https://github.com/PennyLaneAI/pennylane/pull/4526)

Consider an operator `A` composed of a linear combination of Pauli terms:

pycon
>>> A = qml.PauliX(2) + 2 * qml.PauliY(2) + 3 * qml.PauliZ(2)


A decomposable block-encoding circuit can be created:

python
def block_encode(A, control_wires):
probs = A.coeffs / np.sum(A.coeffs)
state = np.pad(np.sqrt(probs, dtype=complex), (0, 1))
unitaries = A.ops

qml.StatePrep(state, wires=control_wires)
qml.Select(unitaries, control=control_wires)
qml.adjoint(qml.StatePrep)(state, wires=control_wires)


pycon
>>> print(qml.draw(block_encode, show_matrices=False)(A, control_wires=[0, 1]))
0: ─╭|Ψ⟩─╭Select─╭|Ψ⟩†─┤
1: ─╰|Ψ⟩─├Select─╰|Ψ⟩†─┤
2: ──────╰Select───────┤


This circuit can be used as a building block within a larger QNode to perform algorithms such as [QSVT](https://docs.pennylane.ai/en/stable/code/api/pennylane.QSVT.html) and [Hamiltonian simulation](https://codebook.xanadu.ai/H.6).

* Decomposing a Hermitian matrix into a linear combination of Pauli words via `qml.pauli_decompose` is now faster and differentiable. [(4395)](https://github.com/PennyLaneAI/pennylane/pull/4395) [(#4479)](https://github.com/PennyLaneAI/pennylane/pull/4479) [(#4493)](https://github.com/PennyLaneAI/pennylane/pull/4493)

python
def find_coeffs(p):
mat = np.array([[3, p], [p, 3]])
A = qml.pauli_decompose(mat)
return A.coeffs


pycon
>>> import jax
>>> from jax import numpy as np
>>> jax.jacobian(find_coeffs)(np.array(2.))
Array([0., 1.], dtype=float32, weak_type=True)


<h4>Monitor PennyLane's inner workings with logging 📃</h4>

* Python-native logging can now be enabled with `qml.logging.enable_logging()`. [(4377)](https://github.com/PennyLaneAI/pennylane/pull/4377) [(#4383)](https://github.com/PennyLaneAI/pennylane/pull/4383)

Consider the following code that is contained in `my_code.py`:

python
import pennylane as qml
qml.logging.enable_logging() enables logging

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

qml.qnode(dev)
def f(x):
qml.RX(x, wires=0)
return qml.state()

f(0.5)


Executing `my_code.py` with logging enabled will detail every step in PennyLane's pipeline that gets used to run your code.


$ python my_code.py
[1967-02-13 15:18:38,591][DEBUG][<PID 8881:MainProcess>] - pennylane.qnode.__init__()::"Creating QNode(func=<function f at 0x7faf2a6fbaf0>, device=<DefaultQubit device (wires=2, shots=None) at 0x7faf2a689b50>, interface=auto, diff_method=best, expansion_strategy=gradient, max_expansion=10, grad_on_execution=best, mode=None, cache=True, cachesize=10000, max_diff=1, gradient_kwargs={}"
...

Additional logging configuration settings can be specified by modifying the contents of the logging configuration file, which can be located by running `qml.logging.config_path()`. Follow our [logging docs page](https://docs.pennylane.ai/en/latest/introduction/logging.html) for more details!

<h4>More input states for quantum chemistry calculations ⚛️</h4>

* Input states obtained from advanced quantum chemistry calculations can be used in a circuit. [(4427)](https://github.com/PennyLaneAI/pennylane/pull/4427) [(#4433)](https://github.com/PennyLaneAI/pennylane/pull/4433) [(#4461)](https://github.com/PennyLaneAI/pennylane/pull/4461) [(#4476)](https://github.com/PennyLaneAI/pennylane/pull/4476) [(#4505)](https://github.com/PennyLaneAI/pennylane/pull/4505)

Quantum chemistry calculations rely on an initial state that is typically selected to be the trivial Hartree-Fock state. For molecules with a complicated electronic structure, using initial states obtained from affordable post-Hartree-Fock calculations helps to improve the efficiency of the quantum simulations. These calculations can be done with external quantum chemistry libraries such as PySCF.

It is now possible to import a PySCF solver object in PennyLane and extract the corresponding wave function in the form of a state vector that can be directly used in a circuit. First, perform your classical quantum chemistry calculations and then use the [qml.qchem.import_state](https://docs.pennylane.ai/en/stable/code/api/pennylane.qchem.import_state.html) function to import the solver object and return a state vector.

pycon
>>> from pyscf import gto, scf, ci
>>> mol = gto.M(atom=[['H', (0, 0, 0)], ['H', (0,0,0.71)]], basis='sto6g')
>>> myhf = scf.UHF(mol).run()
>>> myci = ci.UCISD(myhf).run()
>>> wf_cisd = qml.qchem.import_state(myci, tol=1e-1)
>>> print(wf_cisd)
[ 0. +0.j 0. +0.j 0. +0.j 0.1066467 +0.j
1. +0.j 0. +0.j 0. +0.j 0. +0.j
2. +0.j 0. +0.j 0. +0.j 0. +0.j
-0.99429698+0.j 0. +0.j 0. +0.j 0. +0.j]


The state vector can be implemented in a circuit using `qml.StatePrep`.

pycon
>>> dev = qml.device('default.qubit', wires=4)
>>> qml.qnode(dev)
... def circuit():
... qml.StatePrep(wf_cisd, wires=range(4))
... return qml.state()
>>> print(circuit())
[ 0. +0.j 0. +0.j 0. +0.j 0.1066467 +0.j
1. +0.j 0. +0.j 0. +0.j 0. +0.j
2. +0.j 0. +0.j 0. +0.j 0. +0.j
-0.99429698+0.j 0. +0.j 0. +0.j 0. +0.j]


The currently supported post-Hartree-Fock methods are RCISD, UCISD, RCCSD, and UCCSD which denote restricted (R) and unrestricted (U) configuration interaction (CI) and coupled cluster (CC) calculations with single and double (SD) excitations.

<h4>Reuse and reset qubits after mid-circuit measurements ♻️</h4>

* PennyLane now allows you to define circuits that reuse a qubit after a mid-circuit measurement has taken place. Optionally, the wire can also be reset to the $|0\rangle$ state. [(4402)](https://github.com/PennyLaneAI/pennylane/pull/4402) [(#4432)](https://github.com/PennyLaneAI/pennylane/pull/4432)

Post-measurement reset can be activated by setting `reset=True` when calling [qml.measure](https://docs.pennylane.ai/en/stable/code/api/pennylane.measure.html). In this version of PennyLane, executing circuits with qubit reuse will result in the [defer_measurements](https://docs.pennylane.ai/en/latest/code/api/pennylane.defer_measurements.html) transform being applied. This transform replaces each reused wire with an *additional* qubit. However, future releases of PennyLane will explore device-level support for qubit reuse without consuming additional qubits.

Qubit reuse and reset is also fully differentiable:

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

qml.qnode(dev)
def circuit(p):
qml.RX(p, wires=0)
m = qml.measure(0, reset=True)
qml.cond(m, qml.Hadamard)(1)

qml.RX(p, wires=0)
m = qml.measure(0)
qml.cond(m, qml.Hadamard)(1)
return qml.expval(qml.PauliZ(1))


pycon
>>> jax.grad(circuit)(0.4)
Array(-0.35867804, dtype=float32, weak_type=True)


You can read more about mid-circuit measurements [in the documentation](https://docs.pennylane.ai/en/latest/introduction/measurements.html#mid-circuit-measurements-and-conditional-operations), and stay tuned for more mid-circuit measurement features in the next few releases!

<h3>Improvements 🛠</h3>

<h4>A new PennyLane drawing style</h4>

* Circuit drawings and plots can now be created following a PennyLane style. [(3950)](https://github.com/PennyLaneAI/pennylane/pull/3950)

The `qml.draw_mpl` function accepts a `style='pennylane'` argument to create PennyLane themed circuit diagrams:

python
def circuit(x, z):
qml.QFT(wires=(0,1,2,3))
qml.Toffoli(wires=(0,1,2))
qml.CSWAP(wires=(0,2,3))
qml.RX(x, wires=0)
qml.CRZ(z, wires=(3,0))
return qml.expval(qml.PauliZ(0))

qml.draw_mpl(circuit, style="pennylane")(1, 1)


<img src="https://docs.pennylane.ai/en/stable/_images/pennylane_style.png" width=50%/>

PennyLane-styled plots can also be drawn by passing `"pennylane.drawer.plot"` to Matplotlib's `plt.style.use` function:

python
import matplotlib.pyplot as plt

plt.style.use("pennylane.drawer.plot")
for i in range(3):
plt.plot(np.random.rand(10))


If the font [Quicksand Bold](https://fonts.google.com/specimen/Quicksand) isn't available, an available default font is used instead.

<h4>Making operators immutable and PyTrees</h4>

* Any class inheriting from `Operator` is now automatically registered as a pytree with JAX. This unlocks the ability to jit functions of `Operator`. [(4458)](https://github.com/PennyLaneAI/pennylane/pull/4458/)

pycon
>>> op = qml.adjoint(qml.RX(1.0, wires=0))
>>> jax.jit(qml.matrix)(op)
Array([[0.87758255-0.j , 0. +0.47942555j],
[0. +0.47942555j, 0.87758255-0.j ]], dtype=complex64, weak_type=True)
>>> jax.tree_util.tree_map(lambda x: x+1, op)
Adjoint(RX(2.0, wires=[0]))


* All `Operator` objects now define `Operator._flatten` and `Operator._unflatten` methods that separate trainable from untrainable components. These methods will be used in serialization and pytree registration. Custom operations may need an update to ensure compatibility with new PennyLane features. [(4483)](https://github.com/PennyLaneAI/pennylane/pull/4483) [(#4314)](https://github.com/PennyLaneAI/pennylane/pull/4314)

* The `QuantumScript` class now has a `bind_new_parameters` method that allows creation of new `QuantumScript` objects with the provided parameters. [(4345)](https://github.com/PennyLaneAI/pennylane/pull/4345)

* The `qml.gradients` module no longer mutates operators in-place for any gradient transforms. Instead, operators that need to be mutated are copied with new parameters. [(4220)](https://github.com/PennyLaneAI/pennylane/pull/4220)

* PennyLane no longer directly relies on `Operator.__eq__`. [(4398)](https://github.com/PennyLaneAI/pennylane/pull/4398)

* `qml.equal` no longer raises errors when operators or measurements of different types are compared. Instead, it returns `False`. [(4315)](https://github.com/PennyLaneAI/pennylane/pull/4315)

<h4>Transforms</h4>

* Transform programs are now integrated with the QNode. [(4404)](https://github.com/PennyLaneAI/pennylane/pull/4404)

python
def null_postprocessing(results: qml.typing.ResultBatch) -> qml.typing.Result:
return results[0]

qml.transforms.core.transform
def scale_shots(tape: qml.tape.QuantumTape, shot_scaling) -> (Tuple[qml.tape.QuantumTape], Callable):
new_shots = tape.shots.total_shots * shot_scaling
new_tape = qml.tape.QuantumScript(tape.operations, tape.measurements, shots=new_shots)
return (new_tape, ), null_postprocessing

dev = qml.devices.experimental.DefaultQubit2()

partial(scale_shots, shot_scaling=2)
qml.qnode(dev, interface=None)
def circuit():
return qml.sample(wires=0)


pycon
>>> circuit(shots=1)
array([False, False])


* Transform Programs, `qml.transforms.core.TransformProgram`, can now be called on a batch of circuits and return a new batch of circuits and a single post processing function. [(4364)](https://github.com/PennyLaneAI/pennylane/pull/4364)

* `TransformDispatcher` now allows registration of custom QNode transforms. [(4466)](https://github.com/PennyLaneAI/pennylane/pull/4466)

* QNode transforms in `qml.qinfo` now support custom wire labels. [4331](https://github.com/PennyLaneAI/pennylane/pull/4331)

* `qml.transforms.adjoint_metric_tensor` now uses the simulation tools in `qml.devices.qubit` instead of private methods of `qml.devices.DefaultQubit`. [(4456)](https://github.com/PennyLaneAI/pennylane/pull/4456)

* Auxiliary wires and device wires are now treated the same way in `qml.transforms.metric_tensor` as in `qml.gradients.hadamard_grad`. All valid wire input formats for `aux_wire` are supported. [(4328)](https://github.com/PennyLaneAI/pennylane/pull/4328)

<h4>Next-generation device API</h4>

* The experimental device interface has been integrated with the QNode for JAX, JAX-JIT, TensorFlow and PyTorch. [(4323)](https://github.com/PennyLaneAI/pennylane/pull/4323) [(#4352)](https://github.com/PennyLaneAI/pennylane/pull/4352) [(#4392)](https://github.com/PennyLaneAI/pennylane/pull/4392) [(#4393)](https://github.com/PennyLaneAI/pennylane/pull/4393)

* The experimental `DefaultQubit2` device now supports computing VJPs and JVPs using the adjoint method. [(4374)](https://github.com/PennyLaneAI/pennylane/pull/4374)

* New functions called `adjoint_jvp` and `adjoint_vjp` that compute the JVP and VJP of a tape using the adjoint method have been added to `qml.devices.qubit.adjoint_jacobian` [(4358)](https://github.com/PennyLaneAI/pennylane/pull/4358)

* `DefaultQubit2` now accepts a `max_workers` argument which controls multiprocessing. A `ProcessPoolExecutor` executes tapes asynchronously using a pool of at most `max_workers` processes. If `max_workers` is `None` or not given, only the current process executes tapes. If you experience any issue, say using JAX, TensorFlow, Torch, try setting `max_workers` to `None`. [(4319)](https://github.com/PennyLaneAI/pennylane/pull/4319) [(#4425)](https://github.com/PennyLaneAI/pennylane/pull/4425)

* `qml.devices.experimental.Device` now accepts a shots keyword argument and has a `shots` property. This property is only used to set defaults for a workflow, and does not directly influence the number of shots used in executions or derivatives. [(4388)](https://github.com/PennyLaneAI/pennylane/pull/4388)

* `expand_fn()` for `DefaultQubit2` has been updated to decompose `StatePrep` operations present in the middle of a circuit. [(4444)](https://github.com/PennyLaneAI/pennylane/pull/4444)

* If no seed is specified on initialization with `DefaultQubit2`, the local random number generator will be seeded from NumPy's global random number generator. [(4394)](https://github.com/PennyLaneAI/pennylane/pull/4394)

<h4>Improvements to machine learning library interfaces</h4>

* `pennylane/interfaces` has been refactored. The `execute_fn` passed to the machine learning framework boundaries is now responsible for converting parameters to NumPy. The gradients module can now handle TensorFlow parameters, but gradient tapes now retain the original `dtype` instead of converting to `float64`. This may cause instability with finite-difference differentiation and `float32` parameters. The machine learning boundary functions are now uncoupled from their legacy counterparts. [(4415)](https://github.com/PennyLaneAI/pennylane/pull/4415)

* `qml.interfaces.set_shots` now accepts a `Shots` object as well as `int`'s and tuples of `int`'s. [(4388)](https://github.com/PennyLaneAI/pennylane/pull/4388)

* Readability improvements and stylistic changes have been made to `pennylane/interfaces/jax_jit_tuple.py` [(4379)](https://github.com/PennyLaneAI/pennylane/pull/4379/)

<h4>Pulses</h4>

* A `HardwareHamiltonian` can now be summed with `int` or `float` objects. A sequence of `HardwareHamiltonian`s can now be summed via the builtin `sum`. [(4343)](https://github.com/PennyLaneAI/pennylane/pull/4343)

* `qml.pulse.transmon_drive` has been updated in accordance with [1904.06560](https://arxiv.org/abs/1904.06560). In particular, the functional form has been changed from $\Omega(t)(\cos(\omega_d t + \phi) X - \sin(\omega_d t + \phi) Y)$ to $\Omega(t) \sin(\omega_d t + \phi) Y$. [(#4418)](https://github.com/PennyLaneAI/pennylane/pull/4418/) [(#4465)](https://github.com/PennyLaneAI/pennylane/pull/4465/) [(#4478)](https://github.com/PennyLaneAI/pennylane/pull/4478/) [(#4418)](https://github.com/PennyLaneAI/pennylane/pull/4418/)

<h4>Other improvements</h4>

* The `qchem` module has been upgraded to use the fermionic operators of the `fermi` module. [4336](https://github.com/PennyLaneAI/pennylane/pull/4336) [#4521](https://github.com/PennyLaneAI/pennylane/pull/4521)

* The calculation of `Sum`, `Prod`, `SProd`, `PauliWord`, and `PauliSentence` sparse matrices are orders of magnitude faster. [(4475)](https://github.com/PennyLaneAI/pennylane/pull/4475) [(#4272)](https://github.com/PennyLaneAI/pennylane/pull/4272) [(#4411)](https://github.com/PennyLaneAI/pennylane/pull/4411)

* A function called `qml.math.fidelity_statevector` that computes the fidelity between two state vectors has been added. [(4322)](https://github.com/PennyLaneAI/pennylane/pull/4322)

* `qml.ctrl(qml.PauliX)` returns a `CNOT`, `Toffoli`, or `MultiControlledX` operation instead of `Controlled(PauliX)`. [(4339)](https://github.com/PennyLaneAI/pennylane/pull/4339)

* When given a callable, `qml.ctrl` now does its custom pre-processing on all queued operators from the callable. [(4370)](https://github.com/PennyLaneAI/pennylane/pull/4370)

* The `qchem` functions `primitive_norm` and `contracted_norm` have been modified to be compatible with higher versions of SciPy. The private function `_fac2` for computing double factorials has also been added. [4321](https://github.com/PennyLaneAI/pennylane/pull/4321)

* `tape_expand` now uses `Operator.decomposition` instead of `Operator.expand` in order to make more performant choices. [(4355)](https://github.com/PennyLaneAI/pennylane/pull/4355)

* CI now runs tests with TensorFlow 2.13.0 [(4472)](https://github.com/PennyLaneAI/pennylane/pull/4472)

* All tests in CI and pre-commit hooks now enable linting. [(4335)](https://github.com/PennyLaneAI/pennylane/pull/4335)

* The default label for a `StatePrepBase` operator is now `|Ψ⟩`. [(4340)](https://github.com/PennyLaneAI/pennylane/pull/4340)

* `Device.default_expand_fn()` has been updated to decompose `qml.StatePrep` operations present in the middle of a provided circuit. [(4437)](https://github.com/PennyLaneAI/pennylane/pull/4437)

* `QNode.construct` has been updated to only apply the `qml.defer_measurements` transform if the device does not natively support mid-circuit measurements. [(4516)](https://github.com/PennyLaneAI/pennylane/pull/4516)

* The application of the `qml.defer_measurements` transform has been moved from `QNode.construct` to `qml.Device.batch_transform` to allow more fine-grain control over when `defer_measurements` should be used. [(4432)](https://github.com/PennyLaneAI/pennylane/pull/4432)

* The label for `ParametrizedEvolution` can display parameters with the requested format as set by the kwarg `decimals`. Array-like parameters are displayed in the same format as matrices and stored in the cache. [(4151)](https://github.com/PennyLaneAI/pennylane/pull/4151)

<h3>Breaking changes 💔</h3>

* Applying gradient transforms to broadcasted/batched tapes has been deactivated until it is consistently supported for QNodes as well. [(4480)](https://github.com/PennyLaneAI/pennylane/pull/4480)

* Gradient transforms no longer implicitly cast `float32` parameters to `float64`. Finite difference differentiation with `float32` parameters may no longer give accurate results. [(4415)](https://github.com/PennyLaneAI/pennylane/pull/4415)

* The `do_queue` keyword argument in `qml.operation.Operator` has been removed. Instead of setting `do_queue=False`, use the `qml.QueuingManager.stop_recording()` context. [(4317)](https://github.com/PennyLaneAI/pennylane/pull/4317)

* `Operator.expand` now uses the output of `Operator.decomposition` instead of what it queues. [(4355)](https://github.com/PennyLaneAI/pennylane/pull/4355)

* The gradients module no longer needs shot information passed to it explicitly, as the shots are on the tapes. [(4448)](https://github.com/PennyLaneAI/pennylane/pull/4448)

* `qml.StatePrep` has been renamed to `qml.StatePrepBase` and `qml.QubitStateVector` has been renamed to `qml.StatePrep`. `qml.operation.StatePrep` and `qml.QubitStateVector` are still accessible. [(4450)](https://github.com/PennyLaneAI/pennylane/pull/4450)

* Support for Python 3.8 has been dropped. [(4453)](https://github.com/PennyLaneAI/pennylane/pull/4453)

* `MeasurementValue`'s signature has been updated to accept a list of `MidMeasureMP`'s rather than a list of their IDs. [(4446)](https://github.com/PennyLaneAI/pennylane/pull/4446)

* The `grouping_type` and `grouping_method` keyword arguments have been removed from `qchem.molecular_hamiltonian`. [(4301)](https://github.com/PennyLaneAI/pennylane/pull/4301)

* `zyz_decomposition` and `xyx_decomposition` have been removed. Use `one_qubit_decomposition` instead. [(4301)](https://github.com/PennyLaneAI/pennylane/pull/4301)

* `LieAlgebraOptimizer` has been removed. Use `RiemannianGradientOptimizer` instead. [(4301)](https://github.com/PennyLaneAI/pennylane/pull/4301)

* `Operation.base_name` has been removed. [(4301)](https://github.com/PennyLaneAI/pennylane/pull/4301)

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

* `qml.math.reduced_dm` has been removed. Use `qml.math.reduce_dm` or `qml.math.reduce_statevector` instead. [(4301)](https://github.com/PennyLaneAI/pennylane/pull/4301)

* The `qml.specs` dictionary no longer supports direct key access to certain keys. [(4301)](https://github.com/PennyLaneAI/pennylane/pull/4301)

Instead, these quantities can be accessed as fields of the new `Resources` object saved under `specs_dict["resources"]`:

- `num_operations` is no longer supported, use `specs_dict["resources"].num_gates`
- `num_used_wires` is no longer supported, use `specs_dict["resources"].num_wires`
- `gate_types` is no longer supported, use `specs_dict["resources"].gate_types`
- `gate_sizes` is no longer supported, use `specs_dict["resources"].gate_sizes`
- `depth` is no longer supported, use `specs_dict["resources"].depth`

* `qml.math.purity`, `qml.math.vn_entropy`, `qml.math.mutual_info`, `qml.math.fidelity`, `qml.math.relative_entropy`, and `qml.math.max_entropy` no longer support state vectors as input. [(4322)](https://github.com/PennyLaneAI/pennylane/pull/4322)

* The private `QuantumScript._prep` list has been removed, and prep operations now go into the `_ops` list. [(4485)](https://github.com/PennyLaneAI/pennylane/pull/4485)

<h3>Deprecations 👋</h3>

* `qml.enable_return` and `qml.disable_return` have been deprecated. Please avoid calling `disable_return`, as the old return system has been deprecated along with these switch functions. [(4316)](https://github.com/PennyLaneAI/pennylane/pull/4316)

* `qml.qchem.jordan_wigner` has been deprecated. Use `qml.jordan_wigner` instead. List input to define the fermionic operator has also been deprecated; the fermionic operators in the `qml.fermi` module should be used instead. [(4332)](https://github.com/PennyLaneAI/pennylane/pull/4332)

* The `qml.RandomLayers.compute_decomposition` keyword argument `ratio_imprimitive` will be changed to `ratio_imprim` to match the call signature of the operation. [(4314)](https://github.com/PennyLaneAI/pennylane/pull/4314)

* The CV observables `qml.X` and `qml.P` have been deprecated. Use `qml.QuadX` and `qml.QuadP` instead. [(4330)](https://github.com/PennyLaneAI/pennylane/pull/4330)

* The method `tape.unwrap()` and corresponding `UnwrapTape` and `Unwrap` classes have been deprecated. Use `convert_to_numpy_parameters` instead. [(4344)](https://github.com/PennyLaneAI/pennylane/pull/4344)

* The `mode` keyword argument in QNode has been deprecated, as it was only used in the old return system (which has also been deprecated). Please use `grad_on_execution` instead. [(4316)](https://github.com/PennyLaneAI/pennylane/pull/4316)

* The `QuantumScript.set_parameters` method and the `QuantumScript.data` setter have been deprecated. Please use `QuantumScript.bind_new_parameters` instead. [(4346)](https://github.com/PennyLaneAI/pennylane/pull/4346)

* The `__eq__` and `__hash__` dunder methods of `Operator` and `MeasurementProcess` will now raise warnings to reflect upcoming changes to operator and measurement process equality and hashing. [(4144)](https://github.com/PennyLaneAI/pennylane/pull/4144) [(#4454)](https://github.com/PennyLaneAI/pennylane/pull/4454) [(#4489)](https://github.com/PennyLaneAI/pennylane/pull/4489) [(#4498)](https://github.com/PennyLaneAI/pennylane/pull/4498)

* The `sampler_seed` argument of `qml.gradients.spsa_grad` has been deprecated, along with a bug fix of the seed-setting behaviour. Instead, the `sampler_rng` argument should be set, either to an integer value, which will be used to create a PRNG internally or to a NumPy pseudo-random number generator created via `np.random.default_rng(seed)`. [(4165)](https://github.com/PennyLaneAI/pennylane/pull/4165)

<h3>Documentation 📝</h3>

* The `qml.pulse.transmon_interaction` and `qml.pulse.transmon_drive` documentation has been updated. [(4327)](https://github.com/PennyLaneAI/pennylane/pull/4327)

* `qml.ApproxTimeEvolution.compute_decomposition()` now has a code example. [(4354)](https://github.com/PennyLaneAI/pennylane/pull/4354)

* The documentation for `qml.devices.experimental.Device` has been improved to clarify some aspects of its use. [(4391)](https://github.com/PennyLaneAI/pennylane/pull/4391)

* Input types and sources for operators in `qml.import_operator` are specified. [(4476)](https://github.com/PennyLaneAI/pennylane/pull/4476)

<h3>Bug fixes 🐛</h3>

* `qml.Projector` is pickle-able again. [(4452)](https://github.com/PennyLaneAI/pennylane/pull/4452)

* `_copy_and_shift_params` does not cast or convert integral types, just relying on `+` and `*`'s casting rules in this case. [(4477)](https://github.com/PennyLaneAI/pennylane/pull/4477)

* Sparse matrix calculations of `SProd`s containing a `Tensor` are now allowed. When using `Tensor.sparse_matrix()`, it is recommended to use the `wire_order` keyword argument over `wires`. [(4424)](https://github.com/PennyLaneAI/pennylane/pull/4424)

* `op.adjoint` has been replaced with `qml.adjoint` in `QNSPSAOptimizer`. [(4421)](https://github.com/PennyLaneAI/pennylane/pull/4421)

* `jax.ad` (deprecated) has been replaced by `jax.interpreters.ad`. [(4403)](https://github.com/PennyLaneAI/pennylane/pull/4403)

* `metric_tensor` stops accidentally catching errors that stem from flawed wires assignments in the original circuit, leading to recursion errors. [(4328)](https://github.com/PennyLaneAI/pennylane/pull/4328)

* A warning is now raised if control indicators are hidden when calling `qml.draw_mpl` [(4295)](https://github.com/PennyLaneAI/pennylane/pull/4295)

* `qml.qinfo.purity` now produces correct results with custom wire labels. [(4331)](https://github.com/PennyLaneAI/pennylane/pull/4331)

* `default.qutrit` now supports all qutrit operations used with `qml.adjoint`. [(4348)](https://github.com/PennyLaneAI/pennylane/pull/4348)

* The observable data of `qml.GellMann` now includes its index, allowing correct comparison between instances of `qml.GellMann`, as well as Hamiltonians and Tensors containing `qml.GellMann`. [(4366)](https://github.com/PennyLaneAI/pennylane/pull/4366)

* `qml.transforms.merge_amplitude_embedding` now works correctly when the `AmplitudeEmbedding`s have a batch dimension. [(4353)](https://github.com/PennyLaneAI/pennylane/pull/4353)

* The `jordan_wigner` function has been modified to work with Hamiltonians built with an active space. [(4372)](https://github.com/PennyLaneAI/pennylane/pull/4372)

* When a `style` option is not provided, `qml.draw_mpl` uses the current style set from `qml.drawer.use_style` instead of `black_white`. [(4357)](https://github.com/PennyLaneAI/pennylane/pull/4357)

* `qml.devices.qubit.preprocess.validate_and_expand_adjoint` no longer sets the trainable parameters of the expanded tape. [(4365)](https://github.com/PennyLaneAI/pennylane/pull/4365)

* `qml.default_expand_fn` now selectively expands operations or measurements allowing more operations to be executed in circuits when measuring non-qwc Hamiltonians. [(4401)](https://github.com/PennyLaneAI/pennylane/pull/4401)

* `qml.ControlledQubitUnitary` no longer reports `has_decomposition` as `True` when it does not really have a decomposition. [(4407)](https://github.com/PennyLaneAI/pennylane/pull/4407)

* `qml.transforms.split_non_commuting` now correctly works on tapes containing both `expval` and `var` measurements. [(4426)](https://github.com/PennyLaneAI/pennylane/pull/4426)

* Subtracting a `Prod` from another operator now works as expected. [(4441)](https://github.com/PennyLaneAI/pennylane/pull/4441)

* The `sampler_seed` argument of `qml.gradients.spsa_grad` has been changed to `sampler_rng`. One can either provide an integer, which will be used to create a PRNG internally. Previously, this lead to the same direction being sampled, when `num_directions` is greater than 1. Alternatively, one can provide a NumPy PRNG, which allows reproducibly calling `spsa_grad` without getting the same results every time. [(4165)](https://github.com/PennyLaneAI/pennylane/pull/4165) [(#4482)](https://github.com/PennyLaneAI/pennylane/pull/4482)

* `qml.math.get_dtype_name` now works with autograd array boxes. [(4494)](https://github.com/PennyLaneAI/pennylane/pull/4494)

* The backprop gradient of `qml.math.fidelity` is now correct. [(4380)](https://github.com/PennyLaneAI/pennylane/pull/4380)

<h3>Contributors ✍️</h3>

This release contains contributions from (in alphabetical order):

Utkarsh Azad,
Thomas Bromley,
Isaac De Vlugt,
Amintor Dusko,
Stepan Fomichev,
Lillian M. A. Frederiksen,
Soran Jahangiri,
Edward Jiang,
Korbinian Kottmann,
Ivana Kurečić,
Christina Lee,
Vincent Michaud-Rioux,
Romain Moyard,
Lee James O'Riordan,
Mudit Pandey,
Borja Requena,
Matthew Silverman,
Jay Soni,
David Wierichs,
Frederik Wilde.