Pennylane

<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.

<h3>Improvements 🛠</h3>

* `data.Dataset` now uses HDF5 instead of dill for serialization. [(4097)](https://github.com/PennyLaneAI/pennylane/pull/4097)

* The `qchem` functions `primitive_norm` and `contracted_norm` are modified to be compatible with higher versions of scipy. [(4321)](https://github.com/PennyLaneAI/pennylane/pull/4321)

<h3>Bug Fixes 🐛</h3>

* Dataset URLs are now properly escaped when fetching from S3. [(4412)](https://github.com/PennyLaneAI/pennylane/pull/4412)

<h3>Contributors ✍️</h3>

This release contains contributions from (in alphabetical order):

Utkarsh Azad, Jack Brown, Diego Guala, Soran Jahangiri, Matthew Silverman

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

<h4>Seamlessly create and combine fermionic operators 🔬</h4>

* Fermionic operators and arithmetic are now available. [(4191)](https://github.com/PennyLaneAI/pennylane/pull/4191) [(#4195)](https://github.com/PennyLaneAI/pennylane/pull/4195) [(#4200)](https://github.com/PennyLaneAI/pennylane/pull/4200) [(#4201)](https://github.com/PennyLaneAI/pennylane/pull/4201) [(#4209)](https://github.com/PennyLaneAI/pennylane/pull/4209) [(#4229)](https://github.com/PennyLaneAI/pennylane/pull/4229) [(#4253)](https://github.com/PennyLaneAI/pennylane/pull/4253) [(#4255)](https://github.com/PennyLaneAI/pennylane/pull/4255) [(#4262)](https://github.com/PennyLaneAI/pennylane/pull/4262) [(#4278)](https://github.com/PennyLaneAI/pennylane/pull/4278)

There are a couple of ways to create fermionic operators with this new feature:

- `qml.FermiC` and `qml.FermiA`: the [fermionic creation](https://docs.pennylane.ai/en/stable/code/api/pennylane.FermiC.html) and [annihilation operators](https://docs.pennylane.ai/en/stable/code/api/pennylane.FermiA.html), respectively. These operators are defined by passing the index of the orbital that the fermionic operator acts on. For instance, the operators `a⁺(0)` and `a(3)` are respectively constructed as

pycon
>>> qml.FermiC(0)
a⁺(0)
>>> qml.FermiA(3)
a(3)


These operators can be composed with (`*`) and linearly combined with (`+` and `-`) other Fermi operators to create arbitrary fermionic Hamiltonians. Multiplying several Fermi operators together creates an operator that we call a Fermi word:

pycon
>>> word = qml.FermiC(0) * qml.FermiA(0) * qml.FermiC(3) * qml.FermiA(3)
>>> word
a⁺(0) a(0) a⁺(3) a(3)


Fermi words can be linearly combined to create a fermionic operator that we call a Fermi sentence:

pycon
>>> sentence = 1.2 * word - 0.345 * qml.FermiC(3) * qml.FermiA(3)
>>> sentence
1.2 * a⁺(0) a(0) a⁺(3) a(3)
- 0.345 * a⁺(3) a(3)


- via [qml.fermi.from_string](https://docs.pennylane.ai/en/stable/code/api/pennylane.fermi.from_string.html): create a fermionic operator that represents multiple creation and annihilation operators being multiplied by each other (a Fermi word).

pycon
>>> qml.fermi.from_string('0+ 1- 0+ 1-')
a⁺(0) a(1) a⁺(0) a(1)
>>> qml.fermi.from_string('0^ 1 0^ 1')
a⁺(0) a(1) a⁺(0) a(1)


Fermi words created with `from_string` can also be linearly combined to create a Fermi sentence:

pycon
>>> word1 = qml.fermi.from_string('0+ 0- 3+ 3-')
>>> word2 = qml.fermi.from_string('3+ 3-')
>>> sentence = 1.2 * word1 + 0.345 * word2
>>> sentence
1.2 * a⁺(0) a(0) a⁺(3) a(3)
+ 0.345 * a⁺(3) a(3)


Additionally, any fermionic operator, be it a single fermionic creation/annihilation operator, a Fermi word, or a Fermi sentence, can be mapped to the qubit basis by using [qml.jordan_wigner](https://docs.pennylane.ai/en/stable/code/api/pennylane.jordan_wigner.html):

pycon
>>> qml.jordan_wigner(sentence)
((0.4725+0j)*(Identity(wires=[0]))) + ((-0.4725+0j)*(PauliZ(wires=[3]))) + ((-0.3+0j)*(PauliZ(wires=[0]))) + ((0.3+0j)*(PauliZ(wires=[0]) PauliZ(wires=[3])))


Learn how to create fermionic Hamiltonians describing some simple chemical systems by checking out our [fermionic operators demo](https://pennylane.ai/qml/demos/tutorial_fermionic_operators)!

<h4>Workflow-level resource estimation 🧮</h4>

* PennyLane's [Tracker](https://docs.pennylane.ai/en/stable/code/api/pennylane.Tracker.html) now monitors the resource requirements of circuits being executed by the device. [(#4045)](https://github.com/PennyLaneAI/pennylane/pull/4045) [(#4110)](https://github.com/PennyLaneAI/pennylane/pull/4110)

Suppose we have a workflow that involves executing circuits with different qubit numbers. We can obtain the resource requirements as a function of the number of qubits by executing the workflow with the `Tracker` context:

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

qml.qnode(dev)
def circuit(n_wires):
for i in range(n_wires):
qml.Hadamard(i)
return qml.probs(range(n_wires))

with qml.Tracker(dev) as tracker:
for i in range(1, 5):
circuit(i)


The resource requirements of individual circuits can then be inspected as follows:

pycon
>>> resources = tracker.history["resources"]
>>> resources[0]
wires: 1
gates: 1
depth: 1
shots: Shots(total=None)
gate_types:
{'Hadamard': 1}
gate_sizes:
{1: 1}
>>> [r.num_wires for r in resources]
[1, 2, 3, 4]


Moreover, it is possible to predict the resource requirements without evaluating circuits using the `null.qubit` device, which follows the standard execution pipeline but returns numeric zeros. Consider the following workflow that takes the gradient of a `50`-qubit circuit:

python
n_wires = 50
dev = qml.device("null.qubit", wires=n_wires)

weight_shape = qml.StronglyEntanglingLayers.shape(2, n_wires)
weights = np.random.random(weight_shape, requires_grad=True)

qml.qnode(dev, diff_method="parameter-shift")
def circuit(weights):
qml.StronglyEntanglingLayers(weights, wires=range(n_wires))
return qml.expval(qml.PauliZ(0))

with qml.Tracker(dev) as tracker:
qml.grad(circuit)(weights)


The tracker can be inspected to extract resource requirements without requiring a 50-qubit circuit run:

pycon
>>> tracker.totals
{'executions': 451, 'batches': 2, 'batch_len': 451}
>>> tracker.history["resources"][0]
wires: 50
gates: 200
depth: 77
shots: Shots(total=None)
gate_types:
{'Rot': 100, 'CNOT': 100}
gate_sizes:
{1: 100, 2: 100}


* Custom operations can now be constructed that solely define resource requirements — an explicit decomposition or matrix representation is not needed. [(4033)](https://github.com/PennyLaneAI/pennylane/pull/4033)

PennyLane is now able to estimate the total resource requirements of circuits that include one or more of these operations, allowing you to estimate requirements for high-level algorithms composed of abstract subroutines.

These operations can be defined by inheriting from [ResourcesOperation](https://docs.pennylane.ai/en/stable/code/api/pennylane.resource.ResourcesOperation.html) and overriding the `resources()` method to return an appropriate [Resources](https://docs.pennylane.ai/en/stable/code/api/pennylane.resource.Resources.html) object:

python
class CustomOp(qml.resource.ResourcesOperation):
def resources(self):
n = len(self.wires)
r = qml.resource.Resources(
num_wires=n,
num_gates=n ** 2,
depth=5,
)
return r


pycon
>>> wires = [0, 1, 2]
>>> c = CustomOp(wires)
>>> c.resources()
wires: 3
gates: 9
depth: 5
shots: Shots(total=None)
gate_types:
{}
gate_sizes:
{}


A quantum circuit that contains `CustomOp` can be created and inspected using [qml.specs](https://docs.pennylane.ai/en/stable/code/api/pennylane.specs.html):

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

qml.qnode(dev)
def circ():
qml.PauliZ(wires=0)
CustomOp(wires)
return qml.state()


pycon
>>> specs = qml.specs(circ)()
>>> specs["resources"].depth
6


<h4>Community contributions from UnitaryHack 🤝</h4>

* [ParametrizedHamiltonian](https://docs.pennylane.ai/en/stable/code/api/pennylane.pulse.ParametrizedHamiltonian.html) now has an improved string representation. [(#4176)](https://github.com/PennyLaneAI/pennylane/pull/4176)

pycon
>>> def f1(p, t): return p[0] * jnp.sin(p[1] * t)
>>> def f2(p, t): return p * t
>>> coeffs = [2., f1, f2]
>>> observables = [qml.PauliX(0), qml.PauliY(0), qml.PauliZ(0)]
>>> qml.dot(coeffs, observables)
(2.0*(PauliX(wires=[0])))
+ (f1(params_0, t)*(PauliY(wires=[0])))
+ (f2(params_1, t)*(PauliZ(wires=[0])))


* The quantum information module now supports [trace distance](https://en.wikipedia.org/wiki/Trace_distance). [(#4181)](https://github.com/PennyLaneAI/pennylane/pull/4181)

Two cases are enabled for calculating the trace distance:

- A QNode transform via [qml.qinfo.trace_distance](https://docs.pennylane.ai/en/stable/code/api/pennylane.qinfo.transforms.trace_distance.html):

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

qml.qnode(dev)
def circuit(param):
qml.RY(param, wires=0)
qml.CNOT(wires=[0, 1])
return qml.state()


pycon
>>> trace_distance_circuit = qml.qinfo.trace_distance(circuit, circuit, wires0=[0], wires1=[0])
>>> x, y = np.array(0.4), np.array(0.6)
>>> trace_distance_circuit((x,), (y,))
0.047862689546603415


- Flexible post-processing via [qml.math.trace_distance](https://docs.pennylane.ai/en/stable/code/api/pennylane.math.trace_distance.html):

pycon
>>> rho = np.array([[0.3, 0], [0, 0.7]])
>>> sigma = np.array([[0.5, 0], [0, 0.5]])
>>> qml.math.trace_distance(rho, sigma)
0.19999999999999998


* It is now possible to prepare qutrit basis states with [qml.QutritBasisState](https://docs.pennylane.ai/en/stable/code/api/pennylane.QutritBasisState.html). [(#4185)](https://github.com/PennyLaneAI/pennylane/pull/4185)

python
wires = range(2)
dev = qml.device("default.qutrit", wires=wires)

qml.qnode(dev)
def qutrit_circuit():
qml.QutritBasisState([1, 1], wires=wires)
qml.TAdd(wires=wires)
return qml.probs(wires=1)


pycon
>>> qutrit_circuit()
array([0., 0., 1.])


* A new transform called [one_qubit_decomposition](https://docs.pennylane.ai/en/stable/code/api/pennylane.transforms.one_qubit_decomposition.html) has been added to provide a unified interface for decompositions of a single-qubit unitary matrix into sequences of X, Y, and Z rotations. All decompositions simplify the rotations angles to be between `0` and `4` pi. [(#4210)](https://github.com/PennyLaneAI/pennylane/pull/4210) [(#4246)](https://github.com/PennyLaneAI/pennylane/pull/4246)

pycon
>>> from pennylane.transforms import one_qubit_decomposition
>>> U = np.array([[-0.28829348-0.78829734j, 0.30364367+0.45085995j],
... [ 0.53396245-0.10177564j, 0.76279558-0.35024096j]])
>>> one_qubit_decomposition(U, 0, "ZYZ")
[RZ(tensor(12.32427531, requires_grad=True), wires=[0]),
RY(tensor(1.14938178, requires_grad=True), wires=[0]),
RZ(tensor(1.73305815, requires_grad=True), wires=[0])]
>>> one_qubit_decomposition(U, 0, "XYX", return_global_phase=True)
[RX(tensor(10.84535137, requires_grad=True), wires=[0]),
RY(tensor(1.39749741, requires_grad=True), wires=[0]),
RX(tensor(0.45246584, requires_grad=True), wires=[0]),
(0.38469215914523336-0.9230449299422961j)*(Identity(wires=[0]))]


* The `has_unitary_generator` attribute in `qml.ops.qubit.attributes` no longer contains operators with non-unitary generators. [(4183)](https://github.com/PennyLaneAI/pennylane/pull/4183)

* PennyLane Docker builds have been updated to include the latest plugins and interface versions. [(4178)](https://github.com/PennyLaneAI/pennylane/pull/4178)

<h4>Extended support for differentiating pulses ⚛️</h4>

* The stochastic parameter-shift gradient method can now be used with hardware-compatible Hamiltonians. [(4132)](https://github.com/PennyLaneAI/pennylane/pull/4132) [(#4215)](https://github.com/PennyLaneAI/pennylane/pull/4215)

This new feature generalizes the stochastic parameter-shift gradient transform for pulses (`stoch_pulse_grad`) to support Hermitian generating terms beyond just Pauli words in pulse Hamiltonians, which makes it hardware-compatible.

* A new differentiation method called [qml.gradients.pulse_generator](https://docs.pennylane.ai/en/stable/code/api/pennylane.gradients.pulse_generator.html) is available, which combines classical processing with the parameter-shift rule for multivariate gates to differentiate pulse programs. Access it in your pulse programs by setting `diff_method=qml.gradients.pulse_generator`. [(#4160)](https://github.com/PennyLaneAI/pennylane/pull/4160)

* `qml.pulse.ParametrizedEvolution` now uses _batched_ compressed sparse row (`BCSR`) format. This allows for computing Jacobians of the unitary directly even when `dense=False`. [(4126)](https://github.com/PennyLaneAI/pennylane/pull/4126)

python
def U(params):
H = jnp.polyval * qml.PauliZ(0) time dependent Hamiltonian
Um = qml.evolve(H, dense=False)(params, t=10.)
return qml.matrix(Um)
params = jnp.array([[0.5]], dtype=complex)
jac = jax.jacobian(U, holomorphic=True)(params)


<h4>Broadcasting and other tweaks to Torch and Keras layers 🦾</h4>

* The `TorchLayer` and `KerasLayer` integrations with `torch.nn` and `Keras` have been upgraded. Consider the following `TorchLayer`:

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

qml.qnode(dev)
def qnode(inputs, weights):
qml.AngleEmbedding(inputs, wires=range(n_qubits))
qml.BasicEntanglerLayers(weights, wires=range(n_qubits))
return [qml.expval(qml.PauliZ(wires=i)) for i in range(n_qubits)]

n_layers = 6
weight_shapes = {"weights": (n_layers, n_qubits)}
qlayer = qml.qnn.TorchLayer(qnode, weight_shapes)


The following features are now available:

- Native support for parameter broadcasting. [(4131)](https://github.com/PennyLaneAI/pennylane/pull/4131)

pycon
>>> batch_size = 10
>>> inputs = torch.rand((batch_size, n_qubits))
>>> qlayer(inputs)
>>> dev.num_executions == 1
True


- The ability to draw a `TorchLayer` and `KerasLayer` using `qml.draw()` and `qml.draw_mpl()`. [(4197)](https://github.com/PennyLaneAI/pennylane/pull/4197)

pycon
>>> print(qml.draw(qlayer, show_matrices=False)(inputs))
0: ─╭AngleEmbedding(M0)─╭BasicEntanglerLayers(M1)─┤ <Z>
1: ─╰AngleEmbedding(M0)─╰BasicEntanglerLayers(M1)─┤ <Z>


- Support for `KerasLayer` model saving and clearer instructions on `TorchLayer` model saving. [(4149)](https://github.com/PennyLaneAI/pennylane/pull/4149) [(#4158)](https://github.com/PennyLaneAI/pennylane/pull/4158)

pycon
>>> torch.save(qlayer.state_dict(), "weights.pt") Saving
>>> qlayer.load_state_dict(torch.load("weights.pt")) Loading
>>> qlayer.eval()


Hybrid models containing `KerasLayer` or `TorchLayer` objects can also be saved and loaded.

<h3>Improvements 🛠</h3>

<h4>A more flexible projector</h4>

* `qml.Projector` now accepts a state vector representation, which enables the creation of projectors in any basis. [(4192)](https://github.com/PennyLaneAI/pennylane/pull/4192)

python
dev = qml.device("default.qubit", wires=2)
qml.qnode(dev)
def circuit(state):
return qml.expval(qml.Projector(state, wires=[0, 1]))
zero_state = [0, 0]
plusplus_state = np.array([1, 1, 1, 1]) / 2


pycon
>>> circuit(zero_state)
tensor(1., requires_grad=True)
>>> circuit(plusplus_state)
tensor(0.25, requires_grad=True)


<h4>Do more with qutrits</h4>

* Three qutrit rotation operators have been added that are analogous to `RX`, `RY`, and `RZ`:

- `qml.TRX`: an X rotation
- `qml.TRY`: a Y rotation
- `qml.TRZ`: a Z rotation

[(2845)](https://github.com/PennyLaneAI/pennylane/pull/2845) [(#2846)](https://github.com/PennyLaneAI/pennylane/pull/2846) [(#2847)](https://github.com/PennyLaneAI/pennylane/pull/2847)

* Qutrit devices now support parameter-shift differentiation. [(2845)](https://github.com/PennyLaneAI/pennylane/pull/2845)

<h4>The qchem module</h4>

* `qchem.molecular_hamiltonian()`, `qchem.qubit_observable()`, `qchem.import_operator()`, and `qchem.dipole_moment()` now return an arithmetic operator if `enable_new_opmath()` is active.
[(4138)](https://github.com/PennyLaneAI/pennylane/pull/4138) [(#4159)](https://github.com/PennyLaneAI/pennylane/pull/4159) [(#4189)](https://github.com/PennyLaneAI/pennylane/pull/4189) [(#4204)](https://github.com/PennyLaneAI/pennylane/pull/4204)

* Non-cubic lattice support for all electron resource estimation has been added. [(3956)](https://github.com/PennyLaneAI/pennylane/pull/3956)

* The `qchem.molecular_hamiltonian()` function has been upgraded to support custom wires for constructing differentiable Hamiltonians. The zero imaginary component of the Hamiltonian coefficients have been removed. [(4050)](https://github.com/PennyLaneAI/pennylane/pull/4050) [(#4094)](https://github.com/PennyLaneAI/pennylane/pull/4094)

* Jordan-Wigner transforms that cache Pauli gate objects have been accelerated. [(4046)](https://github.com/PennyLaneAI/pennylane/pull/4046)

* An error is now raised by `qchem.molecular_hamiltonian` when the `dhf` method is used for an open-shell system. This duplicates a similar error in `qchem.Molecule` but makes it clear that the `pyscf` backend can be used for open-shell calculations. [(4058)](https://github.com/PennyLaneAI/pennylane/pull/4058)

* Updated various qubit tapering methods to support operator arithmetic. [(4252)](https://github.com/PennyLaneAI/pennylane/pull/4252)

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

* The new device interface has been integrated with `qml.execute` for autograd, backpropagation, and no differentiation. [(3903)](https://github.com/PennyLaneAI/pennylane/pull/3903)

* Support for adjoint differentiation has been added to the `DefaultQubit2` device. [(4037)](https://github.com/PennyLaneAI/pennylane/pull/4037)

* A new function called `measure_with_samples` that returns a sample-based measurement result given a state has been added. [(4083)](https://github.com/PennyLaneAI/pennylane/pull/4083) [(#4093)](https://github.com/PennyLaneAI/pennylane/pull/4093) [(#4162)](https://github.com/PennyLaneAI/pennylane/pull/4162) [(#4254)](https://github.com/PennyLaneAI/pennylane/pull/4254)

* `DefaultQubit2.preprocess` now returns a new `ExecutionConfig` object with decisions for `gradient_method`, `use_device_gradient`, and `grad_on_execution`. [(4102)](https://github.com/PennyLaneAI/pennylane/pull/4102)

* Support for sample-based measurements has been added to the `DefaultQubit2` device. [(4105)](https://github.com/PennyLaneAI/pennylane/pull/4105) [(#4114)](https://github.com/PennyLaneAI/pennylane/pull/4114) [(#4133)](https://github.com/PennyLaneAI/pennylane/pull/4133) [(#4172)](https://github.com/PennyLaneAI/pennylane/pull/4172)

* The `DefaultQubit2` device now has a `seed` keyword argument. [(4120)](https://github.com/PennyLaneAI/pennylane/pull/4120)

* Added a `dense` keyword to `ParametrizedEvolution` that allows forcing dense or sparse matrices. [(4079)](https://github.com/PennyLaneAI/pennylane/pull/4079) [(#4095)](https://github.com/PennyLaneAI/pennylane/pull/4095) [(#4285)](https://github.com/PennyLaneAI/pennylane/pull/4285)

* Adds the Type variables `pennylane.typing.Result` and `pennylane.typing.ResultBatch` for type hinting the result of an execution. [(4018)](https://github.com/PennyLaneAI/pennylane/pull/4108)

* `qml.devices.ExecutionConfig` no longer has a `shots` property, as it is now on the `QuantumScript`. It now has a `use_device_gradient` property. `ExecutionConfig.grad_on_execution = None` indicates a request for `"best"`, instead of a string. [(4102)](https://github.com/PennyLaneAI/pennylane/pull/4102)

* The new device interface for Jax has been integrated with `qml.execute`. [(4137)](https://github.com/PennyLaneAI/pennylane/pull/4137)

* The new device interface is now integrated with `qml.execute` for Tensorflow. [(4169)](https://github.com/PennyLaneAI/pennylane/pull/4169)

* The experimental device `DefaultQubit2` now supports `qml.Snapshot`. [(4193)](https://github.com/PennyLaneAI/pennylane/pull/4193)

* The experimental device interface is integrated with the `QNode`. [(4196)](https://github.com/PennyLaneAI/pennylane/pull/4196)

* The new device interface in integrated with `qml.execute` for Torch. [(4257)](https://github.com/PennyLaneAI/pennylane/pull/4257)

<h4>Handling shots</h4>

* `QuantumScript` now has a `shots` property, allowing shots to be tied to executions instead of devices. [(4067)](https://github.com/PennyLaneAI/pennylane/pull/4067) [(#4103)](https://github.com/PennyLaneAI/pennylane/pull/4103) [(#4106)](https://github.com/PennyLaneAI/pennylane/pull/4106) [(#4112)](https://github.com/PennyLaneAI/pennylane/pull/4112)

* Several Python built-in functions are now properly defined for instances of the `Shots` class.

- `print`: printing `Shots` instances is now human-readable
- `str`: converting `Shots` instances to human-readable strings
- `==`: equating two different `Shots` instances
- `hash`: obtaining the hash values of `Shots` instances

[(4081)](https://github.com/PennyLaneAI/pennylane/pull/4081) [(#4082)](https://github.com/PennyLaneAI/pennylane/pull/4082)

* `qml.devices.ExecutionConfig` no longer has a `shots` property, as it is now on the `QuantumScript`. It now has a `use_device_gradient` property. `ExecutionConfig.grad_on_execution = None` indicates a request for `"best"` instead of a string. [(4102)](https://github.com/PennyLaneAI/pennylane/pull/4102)

* `QuantumScript.shots` has been integrated with QNodes so that shots are placed on the `QuantumScript` during `QNode` construction. [(4110)](https://github.com/PennyLaneAI/pennylane/pull/4110)

* The `gradients` module has been updated to use the new `Shots` object internally [(4152)](https://github.com/PennyLaneAI/pennylane/pull/4152)

<h4>Operators</h4>

* `qml.prod` now accepts a single quantum function input for creating new `Prod` operators. [(4011)](https://github.com/PennyLaneAI/pennylane/pull/4011)

* `DiagonalQubitUnitary` now decomposes into `RZ`, `IsingZZ` and `MultiRZ` gates instead of a `QubitUnitary` operation with a dense matrix. [(4035)](https://github.com/PennyLaneAI/pennylane/pull/4035)

* All objects being queued in an `AnnotatedQueue` are now wrapped so that `AnnotatedQueue` is not dependent on the has of any operators or measurement processes. [(4087)](https://github.com/PennyLaneAI/pennylane/pull/4087)

* A `dense` keyword to `ParametrizedEvolution` that allows forcing dense or sparse matrices has been added. [(4079)](https://github.com/PennyLaneAI/pennylane/pull/4079) [(#4095)](https://github.com/PennyLaneAI/pennylane/pull/4095)

* Added a new function `qml.ops.functions.bind_new_parameters` that creates a copy of an operator with new parameters without mutating the original operator. [(4113)](https://github.com/PennyLaneAI/pennylane/pull/4113) [(#4256)](https://github.com/PennyLaneAI/pennylane/pull/4256)

* `qml.CY` has been moved from `qml.ops.qubit.non_parametric_ops` to `qml.ops.op_math.controlled_ops` and now inherits from `qml.ops.op_math.ControlledOp`. [(4116)](https://github.com/PennyLaneAI/pennylane/pull/4116/)

* `qml.CZ` now inherits from the `ControlledOp` class and supports exponentiation to arbitrary powers with `pow`, which is no longer limited to integers. It also supports `sparse_matrix` and `decomposition` representations. [(4117)](https://github.com/PennyLaneAI/pennylane/pull/4117)

* The construction of the Pauli representation for the `Sum` class is now faster. [(4142)](https://github.com/PennyLaneAI/pennylane/pull/4142)

* `qml.drawer.drawable_layers.drawable_layers` and `qml.CircuitGraph` have been updated to not rely on `Operator` equality or hash to work correctly. [(4143)](https://github.com/PennyLaneAI/pennylane/pull/4143)

<h4>Other improvements</h4>

* A transform dispatcher and program have been added. [(4109)](https://github.com/PennyLaneAI/pennylane/pull/4109) [(#4187)](https://github.com/PennyLaneAI/pennylane/pull/4187)

* Reduced density matrix functionality has been added via `qml.math.reduce_dm` and `qml.math.reduce_statevector`. Both functions have broadcasting support. [(4173)](https://github.com/PennyLaneAI/pennylane/pull/4173)

* The following functions in `qml.qinfo` now support parameter broadcasting:

- `reduced_dm`
- `purity`
- `vn_entropy`
- `mutual_info`
- `fidelity`
- `relative_entropy`
- `trace_distance`

[(4234)](https://github.com/PennyLaneAI/pennylane/pull/4234)

* The following functions in `qml.math` now support parameter broadcasting:

- `purity`
- `vn_entropy`
- `mutual_info`
- `fidelity`
- `relative_entropy`
- `max_entropy`
- `sqrt_matrix`

[(4186)](https://github.com/PennyLaneAI/pennylane/pull/4186)

* `pulse.ParametrizedEvolution` now raises an error if the number of input parameters does not match the number of parametrized coefficients in the `ParametrizedHamiltonian` that generates it. An exception is made for `HardwareHamiltonian`s which are not checked. [(4216)](https://github.com/PennyLaneAI/pennylane/pull/4216)

* The default value for the `show_matrices` keyword argument in all drawing methods is now `True`. This allows for quick insights into broadcasted tapes, for example. [(3920)](https://github.com/PennyLaneAI/pennylane/pull/3920)

* Type variables for `qml.typing.Result` and `qml.typing.ResultBatch` have been added for type hinting the result of an execution. [(4108)](https://github.com/PennyLaneAI/pennylane/pull/4108)

* The Jax-JIT interface now uses symbolic zeros to determine trainable parameters. [(4075)](https://github.com/PennyLaneAI/pennylane/pull/4075)

* A new function called `pauli.pauli_word_prefactor()` that extracts the prefactor for a given Pauli word has been added. [(4164)](https://github.com/PennyLaneAI/pennylane/pull/4164)

* Variable-length argument lists of functions and methods in some docstrings is now more clear. [(4242)](https://github.com/PennyLaneAI/pennylane/pull/4242)

* `qml.drawer.drawable_layers.drawable_layers` and `qml.CircuitGraph` have been updated to not rely on `Operator` equality or hash to work correctly. [(4143)](https://github.com/PennyLaneAI/pennylane/pull/4143)

* Drawing mid-circuit measurements connected by classical control signals to conditional operations is now possible. [(4228)](https://github.com/PennyLaneAI/pennylane/pull/4228)

* The autograd interface now submits all required tapes in a single batch on the backward pass. [(4245)](https://github.com/PennyLaneAI/pennylane/pull/4245)

<h3>Breaking changes 💔</h3>

* The default value for the `show_matrices` keyword argument in all drawing methods is now `True`. This allows for quick insights into broadcasted tapes, for example. [(3920)](https://github.com/PennyLaneAI/pennylane/pull/3920)

* `DiagonalQubitUnitary` now decomposes into `RZ`, `IsingZZ`, and `MultiRZ` gates rather than a `QubitUnitary`. [(4035)](https://github.com/PennyLaneAI/pennylane/pull/4035)

* Jax trainable parameters are now `Tracer` instead of `JVPTracer`. It is not always the right definition for the JIT interface, but we update them in the custom JVP using symbolic zeros. [(4075)](https://github.com/PennyLaneAI/pennylane/pull/4075)

* The experimental Device interface `qml.devices.experimental.Device` now requires that the `preprocess` method also returns an `ExecutionConfig` object. This allows the device to choose what `"best"` means for various hyperparameters like `gradient_method` and `grad_on_execution`. [(4007)](https://github.com/PennyLaneAI/pennylane/pull/4007) [(#4102)](https://github.com/PennyLaneAI/pennylane/pull/4102)

* Gradient transforms with Jax no longer support `argnum`. Use `argnums` instead. [(4076)](https://github.com/PennyLaneAI/pennylane/pull/4076)

* `qml.collections`, `qml.op_sum`, and `qml.utils.sparse_hamiltonian` have been removed. [(4071)](https://github.com/PennyLaneAI/pennylane/pull/4071)

* The `pennylane.transforms.qcut` module now uses `(op, id(op))` as nodes in directed multigraphs that are used within the circuit cutting workflow instead of `op`. This change removes the dependency of the module on the hash of operators. [(4227)](https://github.com/PennyLaneAI/pennylane/pull/4227)

* `Operator.data` now returns a `tuple` instead of a `list`. [(4222)](https://github.com/PennyLaneAI/pennylane/pull/4222)

* The pulse differentiation methods, `pulse_generator` and `stoch_pulse_grad`, now raise an error when they are applied to a QNode directly. Instead, use differentiation via a JAX entry point (`jax.grad`, `jax.jacobian`, ...). [(4241)](https://github.com/PennyLaneAI/pennylane/pull/4241)

<h3>Deprecations 👋</h3>

* `LieAlgebraOptimizer` has been renamed to `RiemannianGradientOptimizer`. [(4153)](https://github.com/PennyLaneAI/pennylane/pull/4153)

* `Operation.base_name` has been deprecated. Please use `Operation.name` or `type(op).__name__` instead.

* `QuantumScript`'s `name` keyword argument and property have been deprecated. This also affects `QuantumTape` and `OperationRecorder`. [(4141)](https://github.com/PennyLaneAI/pennylane/pull/4141)

* The `qml.grouping` module has been removed. Its functionality has been reorganized in the `qml.pauli` module.

* The public methods of `DefaultQubit` are pending changes to follow the new device API, as used in `DefaultQubit2`. Warnings have been added to the docstrings to reflect this. [(4145)](https://github.com/PennyLaneAI/pennylane/pull/4145)

* `qml.math.reduced_dm` has been deprecated. Please use `qml.math.reduce_dm` or `qml.math.reduce_statevector` instead. [(4173)](https://github.com/PennyLaneAI/pennylane/pull/4173)

* `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. Please call `qml.math.dm_from_state_vector` on the input before passing to any of these functions. [(4186)](https://github.com/PennyLaneAI/pennylane/pull/4186)

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

* `zyz_decomposition` and `xyx_decomposition` are now deprecated in favour of `one_qubit_decomposition`. [(4230)](https://github.com/PennyLaneAI/pennylane/pull/4230)

<h3>Documentation 📝</h3>

* The documentation is updated to construct `QuantumTape` upon initialization instead of with queuing. [(4243)](https://github.com/PennyLaneAI/pennylane/pull/4243)

* The docstring for `qml.ops.op_math.Pow.__new__` is now complete and it has been updated along with `qml.ops.op_math.Adjoint.__new__`. [(4231)](https://github.com/PennyLaneAI/pennylane/pull/4231)

* The docstring for `qml.grad` now states that it should be used with the Autograd interface only. [(4202)](https://github.com/PennyLaneAI/pennylane/pull/4202)

* The description of `mult` in the `qchem.Molecule` docstring now correctly states the value of `mult` that is supported. [(4058)](https://github.com/PennyLaneAI/pennylane/pull/4058)

<h3>Bug Fixes 🐛</h3>

* Fixed adjoint jacobian results with `grad_on_execution=False` in the JAX-JIT interface. [(4217)](https://github.com/PennyLaneAI/pennylane/pull/4217)

* Fixed the matrix of `SProd` when the coefficient is tensorflow and the target matrix is not `complex128`. [(4249)](https://github.com/PennyLaneAI/pennylane/pull/4249)

* Fixed a bug where `stoch_pulse_grad` would ignore prefactors of rescaled Pauli words in the generating terms of a pulse Hamiltonian. [(4156)](https://github.com/PennyLaneAI/pennylane/pull/4156)

* Fixed a bug where the wire ordering of the `wires` argument to `qml.density_matrix` was not taken into account. [(4072)](https://github.com/PennyLaneAI/pennylane/pull/4072)

* A patch in `interfaces/autograd.py` that checks for the `strawberryfields.gbs` device has been removed. That device is pinned to PennyLane <= v0.29.0, so that patch is no longer necessary. [(4089)](https://github.com/PennyLaneAI/pennylane/pull/4089)

* `qml.pauli.are_identical_pauli_words` now treats all identities as equal. Identity terms on Hamiltonians with non-standard wire orders are no longer eliminated. [(4161)](https://github.com/PennyLaneAI/pennylane/pull/4161)

* `qml.pauli_sentence()` is now compatible with empty Hamiltonians `qml.Hamiltonian([], [])`. [(4171)](https://github.com/PennyLaneAI/pennylane/pull/4171)

* Fixed a bug with Jax where executing multiple tapes with `gradient_fn="device"` would fail. [(4190)](https://github.com/PennyLaneAI/pennylane/pull/4190)

* A more meaningful error message is raised when broadcasting with adjoint differentiation on `DefaultQubit`. [(4203)](https://github.com/PennyLaneAI/pennylane/pull/4203)

* The `has_unitary_generator` attribute in `qml.ops.qubit.attributes` no longer contains operators with non-unitary generators. [(4183)](https://github.com/PennyLaneAI/pennylane/pull/4183)

* Fixed a bug where `op = qml.qsvt()` was incorrect up to a global phase when using `convention="Wx""` and `qml.matrix(op)`. [(4214)](https://github.com/PennyLaneAI/pennylane/pull/4214)

* Fixed a buggy calculation of the angle in `xyx_decomposition` that causes it to give an incorrect decomposition. An `if` conditional was intended to prevent divide by zero errors, but the division was by the sine of the argument. So, any multiple of $\pi$ should trigger the conditional, but it was only checking if the argument was 0. Example: `qml.Rot(2.3, 2.3, 2.3)` [(4210)](https://github.com/PennyLaneAI/pennylane/pull/4210)

* Fixed bug that caused `ShotAdaptiveOptimizer` to truncate dimensions of parameter-distributed shots during optimization. [(4240)](https://github.com/PennyLaneAI/pennylane/pull/4240)

* `Sum` observables can now have trainable parameters. [(4251)](https://github.com/PennyLaneAI/pennylane/pull/4251) [(#4275)](https://github.com/PennyLaneAI/pennylane/pull/4275)

<h3>Contributors ✍️</h3>

This release contains contributions from (in alphabetical order):

Venkatakrishnan AnushKrishna,
Utkarsh Azad,
Thomas Bromley,
Isaac De Vlugt,
Lillian M. A. Frederiksen,
Emiliano Godinez Ramirez
Nikhil Harle
Soran Jahangiri,
Edward Jiang,
Korbinian Kottmann,
Christina Lee,
Vincent Michaud-Rioux,
Romain Moyard,
Tristan Nemoz,
Mudit Pandey,
Manul Patel,
Borja Requena,
Modjtaba Shokrian-Zini,
Mainak Roy,
Matthew Silverman,
Jay Soni,
Edward Thomas,
David Wierichs,
Frederik Wilde.

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

<h4>Pulse programming on hardware ⚛️🔬</h4>

* Support for loading time-dependent Hamiltonians that are compatible with quantum hardware has been added, making it possible to load a Hamiltonian that describes an ensemble of Rydberg atoms or a collection of transmon qubits. [(3749)](https://github.com/PennyLaneAI/pennylane/pull/3749) [(#3911)](https://github.com/PennyLaneAI/pennylane/pull/3911) [(#3930)](https://github.com/PennyLaneAI/pennylane/pull/3930) [(#3936)](https://github.com/PennyLaneAI/pennylane/pull/3936) [(#3966)](https://github.com/PennyLaneAI/pennylane/pull/3966) [(#3987)](https://github.com/PennyLaneAI/pennylane/pull/3987) [(#4021)](https://github.com/PennyLaneAI/pennylane/pull/4021) [(#4040)](https://github.com/PennyLaneAI/pennylane/pull/4040)

[Rydberg atoms](https://en.wikipedia.org/wiki/Rydberg_atom) are the foundational unit for neutral atom quantum computing. A Rydberg-system Hamiltonian can be constructed from a [drive term](https://docs.pennylane.ai/en/stable/code/api/pennylane.pulse.rydberg_drive.html)
* `qml.pulse.rydberg_drive` — and an
[interaction term](https://docs.pennylane.ai/en/stable/code/api/pennylane.pulse.rydberg_interaction.html)
* `qml.pulse.rydberg_interaction`:

python
from jax import numpy as jnp

atom_coordinates = [[0, 0], [0, 4], [4, 0], [4, 4]]
wires = [0, 1, 2, 3]

amplitude = lambda p, t: p * jnp.sin(jnp.pi * t)
phase = jnp.pi / 2
detuning = 3 * jnp.pi / 4

H_d = qml.pulse.rydberg_drive(amplitude, phase, detuning, wires)
H_i = qml.pulse.rydberg_interaction(atom_coordinates, wires)
H = H_d + H_i


The time-dependent Hamiltonian `H` can be used in a PennyLane pulse-level differentiable circuit:

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

qml.qnode(dev, interface="jax")
def circuit(params):
qml.evolve(H)(params, t=[0, 10])
return qml.expval(qml.PauliZ(0))


pycon
>>> params = jnp.array([2.4])
>>> circuit(params)
Array(0.6316659, dtype=float32)
>>> import jax
>>> jax.grad(circuit)(params)
Array([1.3116529], dtype=float32)


The [qml.pulse](https://docs.pennylane.ai/en/stable/code/qml_pulse.html) page contains additional details. Check out our [release blog post](https://pennylane.ai/blog/2023/05/pennylane-v030-released/) for demonstration of how to perform the execution on actual hardware!

* A pulse-level circuit can now be differentiated using a [stochastic parameter-shift](https://arxiv.org/abs/2210.15812) method. [(#3780)](https://github.com/PennyLaneAI/pennylane/pull/3780) [(#3900)](https://github.com/PennyLaneAI/pennylane/pull/3900) [(#4000)](https://github.com/PennyLaneAI/pennylane/pull/4000) [(#4004)](https://github.com/PennyLaneAI/pennylane/pull/4004)

The new [qml.gradient.stoch_pulse_grad](https://docs.pennylane.ai/en/stable/code/api/pennylane.gradients.stoch_pulse_grad.html) differentiation method unlocks stochastic-parameter-shift differentiation for pulse-level circuits. The current version of this new method is restricted to Hamiltonians composed of parametrized [Pauli words](https://docs.pennylane.ai/en/stable/code/api/pennylane.pauli.PauliWord.html), but future updates to extend to parametrized [Pauli sentences](https://docs.pennylane.ai/en/stable/code/api/pennylane.pauli.PauliSentence.html) can allow this method to be compatible with hardware-based systems such as an ensemble of Rydberg atoms.

This method can be activated by setting `diff_method` to [qml.gradient.stoch_pulse_grad](https://docs.pennylane.ai/en/stable/code/api/pennylane.gradients.stoch_pulse_grad.html):

pycon
>>> dev = qml.device("default.qubit.jax", wires=2)
>>> sin = lambda p, t: jax.numpy.sin(p * t)
>>> ZZ = qml.PauliZ(0) qml.PauliZ(1)
>>> H = 0.5 * qml.PauliX(0) + qml.pulse.constant * ZZ + sin * qml.PauliX(1)
>>> qml.qnode(dev, interface="jax", diff_method=qml.gradients.stoch_pulse_grad)
>>> def ansatz(params):
... qml.evolve(H)(params, (0.2, 1.))
... return qml.expval(qml.PauliY(1))
>>> params = [jax.numpy.array(0.4), jax.numpy.array(1.3)]
>>> jax.grad(ansatz)(params)
[Array(0.16921353, dtype=float32, weak_type=True),
Array(-0.2537478, dtype=float32, weak_type=True)]


<h4>Quantum singular value transformation 🐛➡️🦋</h4>

* PennyLane now supports the [quantum singular value transformation](https://arxiv.org/abs/1806.01838) (QSVT), which describes how a quantum circuit can be constructed to apply a polynomial transformation to the singular values of an input matrix. [(#3756)](https://github.com/PennyLaneAI/pennylane/pull/3756) [(#3757)](https://github.com/PennyLaneAI/pennylane/pull/3757) [(#3758)](https://github.com/PennyLaneAI/pennylane/pull/3758) [(#3905)](https://github.com/PennyLaneAI/pennylane/pull/3905) [(#3909)](https://github.com/PennyLaneAI/pennylane/pull/3909) [(#3926)](https://github.com/PennyLaneAI/pennylane/pull/3926) [(#4023)](https://github.com/PennyLaneAI/pennylane/pull/4023)

Consider a matrix `A` along with a vector `angles` that describes the target polynomial transformation. The `qml.qsvt` function creates a corresponding circuit:

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

A = np.array([[0.1, 0.2], [0.3, 0.4]])
angles = np.array([0.1, 0.2, 0.3])

qml.qnode(dev)
def example_circuit(A):
qml.qsvt(A, angles, wires=[0, 1])
return qml.expval(qml.PauliZ(wires=0))


This circuit is composed of `qml.BlockEncode` and `qml.PCPhase` operations.

pycon
>>> example_circuit(A)
tensor(0.97777078, requires_grad=True)
>>> print(example_circuit.qtape.expand(depth=1).draw(decimals=2))
0: ─╭∏_ϕ(0.30)─╭BlockEncode(M0)─╭∏_ϕ(0.20)─╭BlockEncode(M0)†─╭∏_ϕ(0.10)─┤ <Z>
1: ─╰∏_ϕ(0.30)─╰BlockEncode(M0)─╰∏_ϕ(0.20)─╰BlockEncode(M0)†─╰∏_ϕ(0.10)─┤


The [qml.qsvt](https://docs.pennylane.ai/en/stable/code/api/pennylane.qsvt.html) function creates a circuit that is targeted at simulators due to the use of matrix-based operations. For advanced users, you can use the [operation-based](https://docs.pennylane.ai/en/stable/code/api/pennylane.QSVT.html) `qml.QSVT` template to perform the transformation with a custom choice of unitary and projector operations, which may be hardware compatible if a decomposition is provided.

The QSVT is a complex but powerful transformation capable of [generalizing important algorithms](https://arxiv.org/abs/2105.02859) like amplitude amplification. Stay tuned for a demo in the coming few weeks to learn more!

<h4>Intuitive QNode returns ↩️</h4>

* An updated QNode return system has been introduced. PennyLane QNodes now return exactly what you tell them to! 🎉 [(3957)](https://github.com/PennyLaneAI/pennylane/pull/3957) [(#3969)](https://github.com/PennyLaneAI/pennylane/pull/3969) [(#3946)](https://github.com/PennyLaneAI/pennylane/pull/3946) [(#3913)](https://github.com/PennyLaneAI/pennylane/pull/3913) [(#3914)](https://github.com/PennyLaneAI/pennylane/pull/3914) [(#3934)](https://github.com/PennyLaneAI/pennylane/pull/3934)

This was an experimental feature introduced in version 0.25 of PennyLane that was enabled via `qml.enable_return()`. Now, it's the default return system. Let's see how it works.

Consider the following circuit:

python
import pennylane as qml

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

qml.qnode(dev)
def circuit(x):
qml.RX(x, wires=0)
return qml.expval(qml.PauliZ(0)), qml.probs(0)


In version 0.29 and earlier of PennyLane, `circuit()` would return a single length-3 array:

pycon
>>> circuit(0.5)
tensor([0.87758256, 0.93879128, 0.06120872], requires_grad=True)


In versions 0.30 and above, `circuit()` returns a length-2 tuple containing the expectation value and probabilities separately:

pycon
>>> circuit(0.5)
(tensor(0.87758256, requires_grad=True),
tensor([0.93879128, 0.06120872], requires_grad=True))


You can find [more details about this change](https://docs.pennylane.ai/en/stable/introduction/returns.html), along with help and troubleshooting tips to solve any issues. If you still have questions, comments, or concerns, we encourage you to post on the PennyLane [discussion forum](https://discuss.pennylane.ai).

<h4>A bunch of performance tweaks 🏃💨</h4>

* Single-qubit operations that have multi-qubit control can now be decomposed more efficiently using fewer CNOT gates. [(3851)](https://github.com/PennyLaneAI/pennylane/pull/3851)

Three decompositions from [arXiv:2302.06377](https://arxiv.org/abs/2302.06377) are provided and compare favourably to the already-available `qml.ops.ctrl_decomp_zyz`:

python
wires = [0, 1, 2, 3, 4, 5]
control_wires = wires[1:]

qml.qnode(qml.device('default.qubit', wires=6))
def circuit():
with qml.QueuingManager.stop_recording():
the decomposition does not un-queue the target
target = qml.RX(np.pi/2, wires=0)
qml.ops.ctrl_decomp_bisect(target, (1,2,3,4,5))
return qml.state()

print(qml.draw(circuit, expansion_strategy="device")())



0: ──H─╭X──U(M0)─╭X──U(M0)†─╭X──U(M0)─╭X──U(M0)†──H─┤ State
1: ────├●────────│──────────├●────────│─────────────┤ State
2: ────├●────────│──────────├●────────│─────────────┤ State
3: ────╰●────────│──────────╰●────────│─────────────┤ State
4: ──────────────├●───────────────────├●────────────┤ State
5: ──────────────╰●───────────────────╰●────────────┤ State


* A new decomposition to `qml.SingleExcitation` has been added that halves the number of CNOTs required. [(3976)](https://github.com/PennyLaneAI/pennylane/pull/3976)

pycon
>>> qml.SingleExcitation.compute_decomposition(1.23, wires=(0,1))
[Adjoint(T(wires=[0])), Hadamard(wires=[0]), S(wires=[0]),
Adjoint(T(wires=[1])), Adjoint(S(wires=[1])), Hadamard(wires=[1]),
CNOT(wires=[1, 0]), RZ(-0.615, wires=[0]), RY(0.615, wires=[1]),
CNOT(wires=[1, 0]), Adjoint(S(wires=[0])), Hadamard(wires=[0]),
T(wires=[0]), Hadamard(wires=[1]), S(wires=[1]), T(wires=[1])]


* The adjoint differentiation method can now be more efficient, avoiding the decomposition of operations that can be differentiated directly. Any operation that defines a ``generator()`` can be differentiated with the adjoint method. [(3874)](https://github.com/PennyLaneAI/pennylane/pull/3874)

For example, in version 0.29 the ``qml.CRY`` operation would be decomposed when calculating the adjoint-method gradient. Executing the code below shows that this decomposition no longer takes place in version 0.30 and ``qml.CRY`` is differentiated directly:

python
import jax
from jax import numpy as jnp

def compute_decomposition(self, phi, wires):
print("A decomposition has been performed!")
decomp_ops = [
qml.RY(phi / 2, wires=wires[1]),
qml.CNOT(wires=wires),
qml.RY(-phi / 2, wires=wires[1]),
qml.CNOT(wires=wires),
]
return decomp_ops

qml.CRY.compute_decomposition = compute_decomposition

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

qml.qnode(dev, diff_method="adjoint")
def circuit(phi):
qml.Hadamard(wires=0)
qml.CRY(phi, wires=[0, 1])
return qml.expval(qml.PauliZ(1))

phi = jnp.array(0.5)
jax.grad(circuit)(phi)


* Derivatives are computed more efficiently when using `jax.jit` with gradient transforms; the trainable parameters are now set correctly instead of every parameter having to be set as trainable.
[(3697)](https://github.com/PennyLaneAI/pennylane/pull/3697)

In the circuit below, only the derivative with respect to parameter `b` is now calculated:

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

qml.qnode(dev, interface="jax-jit")
def circuit(a, b):
qml.RX(a, wires=0)
qml.RY(b, wires=0)
qml.CNOT(wires=[0, 1])
return qml.expval(qml.PauliZ(0))

a = jnp.array(0.4)
b = jnp.array(0.5)

jac = jax.jacobian(circuit, argnums=[1])
jac_jit = jax.jit(jac)

jac_jit(a, b)
assert len(circuit.tape.trainable_params) == 1


<h3>Improvements 🛠</h3>

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

In this release and future releases, we will be making changes to our device API with the goal in mind to make
developing plugins much easier for developers and unlock new device capabilities. Users shouldn't yet feel any of
these changes when using PennyLane, but here is what has changed this release:

* Several functions in `devices/qubit` have been added or improved:
- `sample_state`: returns a series of samples based on a given state vector and a number of shots. [(3720)](https://github.com/PennyLaneAI/pennylane/pull/3720)
- `simulate`: supports measuring expectation values of large observables such as `qml.Hamiltonian`, `qml.SparseHamiltonian`, and `qml.Sum`. [(3759)](https://github.com/PennyLaneAI/pennylane/pull/3759)
- `apply_operation`: supports broadcasting. [(3852)](https://github.com/PennyLaneAI/pennylane/pull/3852)
- `adjoint_jacobian`: supports adjoint differentiation in the new qubit state-vector device. [(3790)](https://github.com/PennyLaneAI/pennylane/pull/3790)

* `qml.devices.qubit.preprocess` now allows circuits with non-commuting observables. [(3857)](https://github.com/PennyLaneAI/pennylane/pull/3857)

* `qml.devices.qubit.measure` now computes the expectation values of `Hamiltonian` and `Sum` in a backpropagation-compatible way. [(3862)](https://github.com/PennyLaneAI/pennylane/pull/3862/)

<h4>Pulse programming</h4>

* Here are the functions, classes, and more that were added or improved to facilitate simulating ensembles of Rydberg atoms: [(3749)](https://github.com/PennyLaneAI/pennylane/pull/3749) [(#3911)](https://github.com/PennyLaneAI/pennylane/pull/3911) [(#3930)](https://github.com/PennyLaneAI/pennylane/pull/3930) [(#3936)](https://github.com/PennyLaneAI/pennylane/pull/3936) [(#3966)](https://github.com/PennyLaneAI/pennylane/pull/3966) [(#3987)](https://github.com/PennyLaneAI/pennylane/pull/3987) [(#3889)](https://github.com/PennyLaneAI/pennylane/pull/3889) [(#4021)](https://github.com/PennyLaneAI/pennylane/pull/4021)
- `HardwareHamiltonian`: an internal class that contains additional information about pulses and settings.
- `rydberg_interaction`: a user-facing function that returns a `HardwareHamiltonian` containing the Hamiltonian of the interaction of all the Rydberg atoms.
- `transmon_interaction`: a user-facing function for constructing the Hamiltonian that describes the circuit QED interaction Hamiltonian of superconducting transmon systems.
- `drive`: a user-facing function function that returns a `ParametrizedHamiltonian` (`HardwareHamiltonian`) containing the Hamiltonian of the interaction between a driving electro-magnetic field and a group of qubits.
- `rydberg_drive`: a user-facing function that returns a `ParametrizedHamiltonian` (`HardwareHamiltonian`) containing the Hamiltonian of the interaction between a driving laser field and a group of Rydberg atoms.
- `max_distance`: a keyword argument added to `qml.pulse.rydberg_interaction` to allow for the removal of negligible contributions from atoms beyond `max_distance` from each other.

* `ParametrizedEvolution` now takes two new Boolean keyword arguments: `return_intermediate` and `complementary`. They allow computing intermediate time evolution matrices. [(3900)](https://github.com/PennyLaneAI/pennylane/pull/3900)

Activating `return_intermediate` will return intermediate time evolution steps, for example for the matrix of the Operation, or of a quantum circuit when used in a QNode. Activating `complementary` will make these intermediate steps be the _remaining_ time evolution complementary to the output for `complementary=False`. See the [docstring](https://docs.pennylane.ai/en/stable/code/api/pennylane.pulse.ParametrizedEvolution.html) for details.

* Hardware-compatible pulse sequence gradients with `qml.gradient.stoch_pulse_grad` can now be calculated faster using the new keyword argument `use_broadcasting`. Executing a `ParametrizedEvolution` that returns intermediate evolutions has increased performance using the state vector ODE solver, as well. [(4000)](https://github.com/PennyLaneAI/pennylane/pull/4000) [(#4004)](https://github.com/PennyLaneAI/pennylane/pull/4004)

<h4>Intuitive QNode returns</h4>

* The QNode keyword argument `mode` has been replaced by the boolean `grad_on_execution`. [(3969)](https://github.com/PennyLaneAI/pennylane/pull/3969)

* The `"default.gaussian"` device and parameter-shift CV both support the new return system, but only for single measurements. [(3946)](https://github.com/PennyLaneAI/pennylane/pull/3946)

* Keras and Torch NN modules are now compatible with the new return type system. [(3913)](https://github.com/PennyLaneAI/pennylane/pull/3913) [(#3914)](https://github.com/PennyLaneAI/pennylane/pull/3914)

* `DefaultQutrit` now supports the new return system. [(3934)](https://github.com/PennyLaneAI/pennylane/pull/3934)

<h4>Performance improvements</h4>

* The efficiency of `tapering()`, `tapering_hf()` and `clifford()` have been improved. [(3942)](https://github.com/PennyLaneAI/pennylane/pull/3942)

* The peak memory requirements of `tapering()` and `tapering_hf()` have been improved when used for larger observables. [(3977)](https://github.com/PennyLaneAI/pennylane/pull/3977)

* Pauli arithmetic has been updated to convert to a Hamiltonian more efficiently. [(3939)](https://github.com/PennyLaneAI/pennylane/pull/3939)

* `Operator` has a new Boolean attribute `has_generator`. It returns whether or not the `Operator` has a `generator` defined. `has_generator` is used in `qml.operation.has_gen`, which improves its performance and extends differentiation support. [(3875)](https://github.com/PennyLaneAI/pennylane/pull/3875)

* The performance of `CompositeOp` has been significantly improved now that it overrides determining whether it is being used with a batch of parameters (see `Operator._check_batching`). `Hamiltonian` also now overrides this, but it does nothing since it does not support batching. [(3915)](https://github.com/PennyLaneAI/pennylane/pull/3915)

* The performance of a `Sum` operator has been significantly improved now that `is_hermitian` checks that all coefficients are real if the operator has a pre-computed Pauli representation. [(3915)](https://github.com/PennyLaneAI/pennylane/pull/3915)

* The `coefficients` function and the `visualize` submodule of the `qml.fourier` module now allow assigning different degrees for different parameters of the input function. [(3005)](https://github.com/PennyLaneAI/pennylane/pull/3005)

Previously, the arguments `degree` and `filter_threshold` to `qml.fourier.coefficients` were expected to be integers. Now, they can be a sequences of integers with one integer per function parameter (i.e. `len(degree)==n_inputs`), resulting in a returned array with shape `(2*degrees[0]+1,..., 2*degrees[-1]+1)`. The functions in `qml.fourier.visualize` accordingly accept such arrays of coefficients.

<h4>Other improvements</h4>

* A `Shots` class has been added to the `measurements` module to hold shot-related data. [(3682)](https://github.com/PennyLaneAI/pennylane/pull/3682)

* The custom JVP rules in PennyLane also now support non-scalar and mixed-shape tape parameters as well as multi-dimensional tape return types, like broadcasted `qml.probs`, for example. [(3766)](https://github.com/PennyLaneAI/pennylane/pull/3766)

* The `qchem.jordan_wigner` function has been extended to support more fermionic operator orders. [(3754)](https://github.com/PennyLaneAI/pennylane/pull/3754) [(#3751)](https://github.com/PennyLaneAI/pennylane/pull/3751)

* The `AdaptiveOptimizer` has been updated to use non-default user-defined QNode arguments. [(3765)](https://github.com/PennyLaneAI/pennylane/pull/3765)

* Operators now use `TensorLike` types dunder methods. [(3749)](https://github.com/PennyLaneAI/pennylane/pull/3749)

* `qml.QubitStateVector.state_vector` now supports broadcasting. [(3852)](https://github.com/PennyLaneAI/pennylane/pull/3852)

* `qml.SparseHamiltonian` can now be applied to any wires in a circuit rather than being restricted to all wires in the circuit. [(3888)](https://github.com/PennyLaneAI/pennylane/pull/3888)

* Operators can now be divided by scalars with `/` with the addition of the `Operation.__truediv__` dunder method. [(3749)](https://github.com/PennyLaneAI/pennylane/pull/3749)

* Printing an instance of `MutualInfoMP` now displays the distribution of the wires between the two subsystems. [(3898)](https://github.com/PennyLaneAI/pennylane/pull/3898)

* `Operator.num_wires` has been changed from an abstract value to `AnyWires`. [(3919)](https://github.com/PennyLaneAI/pennylane/pull/3919)

* `qml.transforms.sum_expand` is not run in `Device.batch_transform` if the device supports `Sum` observables. [(3915)](https://github.com/PennyLaneAI/pennylane/pull/3915)

* The type of `n_electrons` in `qml.qchem.Molecule` has been set to `int`. [(3885)](https://github.com/PennyLaneAI/pennylane/pull/3885)

* Explicit errors have been added to `QutritDevice` if `classical_shadow` or `shadow_expval` is measured. [(3934)](https://github.com/PennyLaneAI/pennylane/pull/3934)

* `QubitDevice` now defines the private `_get_diagonalizing_gates(circuit)` method and uses it when executing circuits. This allows devices that inherit from `QubitDevice` to override and customize their definition of diagonalizing gates. [(3938)](https://github.com/PennyLaneAI/pennylane/pull/3938)

* `retworkx` has been renamed to `rustworkx` to accommodate the change in the package name. [(3975)](https://github.com/PennyLaneAI/pennylane/pull/3975)

* `Exp`, `Sum`, `Prod`, and `SProd` operator data is now a flat list instead of nested. [(3958)](https://github.com/PennyLaneAI/pennylane/pull/3958) [(#3983)](https://github.com/PennyLaneAI/pennylane/pull/3983)

* `qml.transforms.convert_to_numpy_parameters` has been added to convert a circuit with interface-specific parameters to one with only numpy parameters. This transform is designed to replace `qml.tape.Unwrap`. [(3899)](https://github.com/PennyLaneAI/pennylane/pull/3899)

* `qml.operation.WiresEnum.AllWires` is now -2 instead of 0 to avoid the ambiguity between `op.num_wires = 0` and `op.num_wires = AllWires`. [(3978)](https://github.com/PennyLaneAI/pennylane/pull/3978)

* Execution code has been updated to use the new `qml.transforms.convert_to_numpy_parameters` instead of `qml.tape.Unwrap`. [(3989)](https://github.com/PennyLaneAI/pennylane/pull/3989)

* A sub-routine of `expand_tape` has been converted into `qml.tape.tape.rotations_and_diagonal_measurements`, a helper function that computes rotations and diagonal measurements for a tape with measurements with overlapping wires. [(3912)](https://github.com/PennyLaneAI/pennylane/pull/3912)

* Various operators and templates have been updated to ensure that their decompositions only return lists of operators. [(3243)](https://github.com/PennyLaneAI/pennylane/pull/3243)

* The `qml.operation.enable_new_opmath` toggle has been introduced to cause dunder methods to return arithmetic operators instead of a `Hamiltonian` or `Tensor`. [(4008)](https://github.com/PennyLaneAI/pennylane/pull/4008)

pycon
>>> type(qml.PauliX(0) qml.PauliZ(1))
<class 'pennylane.operation.Tensor'>
>>> qml.operation.enable_new_opmath()
>>> type(qml.PauliX(0) qml.PauliZ(1))
<class 'pennylane.ops.op_math.prod.Prod'>
>>> qml.operation.disable_new_opmath()
>>> type(qml.PauliX(0) qml.PauliZ(1))
<class 'pennylane.operation.Tensor'>


* A new data class called `Resources` has been added to store resources like the number of gates and circuit depth throughout a quantum circuit. [(3981)](https://github.com/PennyLaneAI/pennylane/pull/3981/)

* A new function called `_count_resources()` has been added to count the resources required when executing a `QuantumTape` for a given number of shots. [(3996)](https://github.com/PennyLaneAI/pennylane/pull/3996)

* `QuantumScript.specs` has been modified to make use of the new `Resources` class. This also modifies the output of `qml.specs()`. [(4015)](https://github.com/PennyLaneAI/pennylane/pull/4015)

* A new class called `ResourcesOperation` has been added to allow users to define operations with custom resource information. [(4026)](https://github.com/PennyLaneAI/pennylane/pull/4026)

For example, users can define a custom operation by inheriting from this new class:

pycon
>>> class CustomOp(qml.resource.ResourcesOperation):
... def resources(self):
... return qml.resource.Resources(num_wires=1, num_gates=2,
... gate_types={"PauliX": 2})
...
>>> CustomOp(wires=1)
CustomOp(wires=[1])


Then, we can track and display the resources of the workflow using `qml.specs()`:

pycon
>>> dev = qml.device("default.qubit", wires=[0,1])
>>> qml.qnode(dev)
... def circ():
... qml.PauliZ(wires=0)
... CustomOp(wires=1)
... return qml.state()
...
>>> print(qml.specs(circ)()['resources'])
wires: 2
gates: 3
depth: 1
shots: 0
gate_types:
{'PauliZ': 1, 'PauliX': 2}


* `MeasurementProcess.shape` now accepts a `Shots` object as one of its arguments to reduce exposure to unnecessary execution details. [(4012)](https://github.com/PennyLaneAI/pennylane/pull/4012)

<h3>Breaking changes 💔</h3>

* The `seed_recipes` argument has been removed from `qml.classical_shadow` and `qml.shadow_expval`. [(4020)](https://github.com/PennyLaneAI/pennylane/pull/4020)

* The tape method `get_operation` has an updated signature. [(3998)](https://github.com/PennyLaneAI/pennylane/pull/3998)

* Both JIT interfaces are no longer compatible with JAX `>0.4.3` (we raise an error for those versions). [(3877)](https://github.com/PennyLaneAI/pennylane/pull/3877)

* An operation that implements a custom `generator` method, but does not always return a valid generator, also has to implement a `has_generator` property that reflects in which scenarios a generator will be returned. [(3875)](https://github.com/PennyLaneAI/pennylane/pull/3875)

* Trainable parameters for the Jax interface are the parameters that are `JVPTracer`, defined by setting `argnums`. Previously, all JAX tracers, including those used for JIT compilation, were interpreted to be trainable. [(3697)](https://github.com/PennyLaneAI/pennylane/pull/3697)

* The keyword argument `argnums` is now used for gradient transforms using Jax instead of `argnum`. `argnum` is automatically converted to `argnums` when using Jax and will no longer be supported in v0.31 of PennyLane. [(3697)](https://github.com/PennyLaneAI/pennylane/pull/3697) [(#3847)](https://github.com/PennyLaneAI/pennylane/pull/3847)

* `qml.OrbitalRotation` and, consequently, `qml.GateFabric` are now more consistent with the interleaved Jordan-Wigner ordering. Previously, they were consistent with the sequential Jordan-Wigner ordering. [(3861)](https://github.com/PennyLaneAI/pennylane/pull/3861)

* Some `MeasurementProcess` classes can now only be instantiated with arguments that they will actually use. For example, you can no longer create `StateMP(qml.PauliX(0))` or `PurityMP(eigvals=(-1,1), wires=Wires(0))`. [(3898)](https://github.com/PennyLaneAI/pennylane/pull/3898)

* `Exp`, `Sum`, `Prod`, and `SProd` operator data is now a flat list, instead of nested. [(3958)](https://github.com/PennyLaneAI/pennylane/pull/3958) [(#3983)](https://github.com/PennyLaneAI/pennylane/pull/3983)

* `qml.tape.tape.expand_tape` and, consequentially, `QuantumScript.expand` no longer update the input tape with rotations and diagonal measurements. Note that the newly expanded tape that is returned will still have the rotations and diagonal measurements. [(3912)](https://github.com/PennyLaneAI/pennylane/pull/3912)

* `qml.Evolution` now initializes the coefficient with a factor of `-1j` instead of `1j`. [(4024)](https://github.com/PennyLaneAI/pennylane/pull/4024)

<h3>Deprecations 👋</h3>

Nothing for this release!

<h3>Documentation 📝</h3>

* The documentation of `QubitUnitary` and `DiagonalQubitUnitary` was clarified regarding the parameters of the operations. [(4031)](https://github.com/PennyLaneAI/pennylane/pull/4031)

* A typo has been corrected in the documentation for the introduction to `inspecting_circuits` and `chemistry`. [(3844)](https://github.com/PennyLaneAI/pennylane/pull/3844)

* `Usage Details` and `Theory` sections have been separated in the documentation for `qml.qchem.taper_operation`. [(3977)](https://github.com/PennyLaneAI/pennylane/pull/3977)

<h3>Bug fixes 🐛</h3>

* `ctrl_decomp_bisect` and `ctrl_decomp_zyz` are no longer used by default when decomposing controlled operations due to the presence of a global phase difference in the zyz decomposition of some target operators.

* Fixed a bug where `qml.math.dot` returned a numpy array instead of an autograd array, breaking autograd derivatives in certain circumstances. [(4019)](https://github.com/PennyLaneAI/pennylane/pull/4019)

* Operators now cast a `tuple` to an `np.ndarray` as well as `list`. [(4022)](https://github.com/PennyLaneAI/pennylane/pull/4022)

* Fixed a bug where `qml.ctrl` with parametric gates was incompatible with PyTorch tensors on GPUs. [(4002)](https://github.com/PennyLaneAI/pennylane/pull/4002)

* Fixed a bug where the broadcast expand results were stacked along the wrong axis for the new return system. [(3984)](https://github.com/PennyLaneAI/pennylane/pull/3984)

* A more informative error message is raised in `qml.jacobian` to explain potential problems with the new return types specification. [(3997)](https://github.com/PennyLaneAI/pennylane/pull/3997)

* Fixed a bug where calling `Evolution.generator` with `coeff` being a complex ArrayBox raised an error. [(3796)](https://github.com/PennyLaneAI/pennylane/pull/3796)

* `MeasurementProcess.hash` now uses the hash property of the observable. The property now depends on all properties that affect the behaviour of the object, such as `VnEntropyMP.log_base` or the distribution of wires between the two subsystems in `MutualInfoMP`. [(3898)](https://github.com/PennyLaneAI/pennylane/pull/3898)

* The enum `measurements.Purity` has been added so that `PurityMP.return_type` is defined. `str` and `repr` for `PurityMP` are also now defined. [(3898)](https://github.com/PennyLaneAI/pennylane/pull/3898)

* `Sum.hash` and `Prod.hash` have been changed slightly to work with non-numeric wire labels. `sum_expand` should now return correct results and not treat some products as the same operation. [(3898)](https://github.com/PennyLaneAI/pennylane/pull/3898)

* Fixed bug where the coefficients where not ordered correctly when summing a `ParametrizedHamiltonian` with other operators. [(3749)](https://github.com/PennyLaneAI/pennylane/pull/3749) [(#3902)](https://github.com/PennyLaneAI/pennylane/pull/3902)

* The metric tensor transform is now fully compatible with Jax and therefore users can provide multiple parameters. [(3847)](https://github.com/PennyLaneAI/pennylane/pull/3847)

* `qml.math.ndim` and `qml.math.shape` are now registered for built-ins and autograd to accomodate Autoray 0.6.1. [3864](https://github.com/PennyLaneAI/pennylane/pull/3865)

* Ensured that `qml.data.load` returns datasets in a stable and expected order. [(3856)](https://github.com/PennyLaneAI/pennylane/pull/3856)

* The `qml.equal` function now handles comparisons of `ParametrizedEvolution` operators. [(3870)](https://github.com/PennyLaneAI/pennylane/pull/3870)

* `qml.devices.qubit.apply_operation` catches the `tf.errors.UnimplementedError` that occurs when `PauliZ` or `CNOT` gates are applied to a large (>8 wires) tensorflow state. When that occurs, the logic falls back to the tensordot logic instead. [(3884)](https://github.com/PennyLaneAI/pennylane/pull/3884/)

* Fixed parameter broadcasting support with `qml.counts` in most cases and introduced explicit errors otherwise. [(3876)](https://github.com/PennyLaneAI/pennylane/pull/3876)

* An error is now raised if a QNode with Jax-jit in use returns `counts` while having trainable parameters [(3892)](https://github.com/PennyLaneAI/pennylane/pull/3892)

* A correction has been added to the reference values in `test_dipole_of` to account for small changes (~`2e-8`) in the computed dipole moment values resulting from the new [PySCF 2.2.0](https://github.com/pyscf/pyscf/releases/tag/v2.2.0) release. [(#3908)](https://github.com/PennyLaneAI/pennylane/pull/3908)

* `SampleMP.shape` is now correct when sampling only occurs on a subset of the device wires. [(3921)](https://github.com/PennyLaneAI/pennylane/pull/3921)

* An issue has been fixed in `qchem.Molecule` to allow basis sets other than the hard-coded ones to be used in the `Molecule` class. [(3955)](https://github.com/PennyLaneAI/pennylane/pull/3955)

* Fixed bug where all devices that inherit from `DefaultQubit` claimed to support `ParametrizedEvolution`. Now, only `DefaultQubitJax` supports the operator, as expected. [(3964)](https://github.com/PennyLaneAI/pennylane/pull/3964)

* Ensured that parallel `AnnotatedQueues` do not queue each other's contents. [(3924)](https://github.com/PennyLaneAI/pennylane/pull/3924)

* Added a `map_wires` method to `PauliWord` and `PauliSentence`, and ensured that operators call it in their respective `map_wires` methods if they have a Pauli rep. [(3985)](https://github.com/PennyLaneAI/pennylane/pull/3985)

* Fixed a bug when a `Tensor` is multiplied by a `Hamiltonian` or vice versa. [(4036)](https://github.com/PennyLaneAI/pennylane/pull/4036)

<h3>Contributors ✍️</h3>

This release contains contributions from (in alphabetical order):

Komi Amiko,
Utkarsh Azad,
Thomas Bromley,
Isaac De Vlugt,
Olivia Di Matteo,
Lillian M. A. Frederiksen,
Diego Guala,
Soran Jahangiri,
Korbinian Kottmann,
Christina Lee,
Vincent Michaud-Rioux,
Albert Mitjans Coma,
Romain Moyard,
Lee J. O'Riordan,
Mudit Pandey,
Matthew Silverman,
Jay Soni,
David Wierichs.

<h3>Bug fixes</h3>

* Defines `qml.math.ndim` and `qml.math.shape` for builtins and autograd. Accommodates changes made by Autograd v0.6.1.

<h3>Contributors</h3>

This release contains contributions from (in alphabetical order):

Christina Lee

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

<h4>Pulse programming 🔊</h4>

* Support for creating pulse-based circuits that describe evolution under a time-dependent Hamiltonian has now been added, as well as the ability to execute and differentiate these pulse-based circuits on simulator.
[(3586)](https://github.com/PennyLaneAI/pennylane/pull/3586)[(#3617)](https://github.com/PennyLaneAI/pennylane/pull/3617)[(#3645)](https://github.com/PennyLaneAI/pennylane/pull/3645)[(#3652)](https://github.com/PennyLaneAI/pennylane/pull/3652)[(#3665)](https://github.com/PennyLaneAI/pennylane/pull/3665)[(#3673)](https://github.com/PennyLaneAI/pennylane/pull/3673)[(#3706)](https://github.com/PennyLaneAI/pennylane/pull/3706)[(#3730)](https://github.com/PennyLaneAI/pennylane/pull/3730)

A time-dependent Hamiltonian can be created using `qml.pulse.ParametrizedHamiltonian`, which holds information representing a linear combination of operators with parametrized coefficents and can be constructed as follows:

python
from jax import numpy as jnp

f1 = lambda p, t: p * jnp.sin(t) * (t - 1)
f2 = lambda p, t: p[0] * jnp.cos(p[1]* t ** 2)

XX = qml.PauliX(0) qml.PauliX(1)
YY = qml.PauliY(0) qml.PauliY(1)
ZZ = qml.PauliZ(0) qml.PauliZ(1)

H = 2 * ZZ + f1 * XX + f2 * YY


pycon
>>> H
ParametrizedHamiltonian: terms=3
>>> p1 = jnp.array(1.2)
>>> p2 = jnp.array([2.3, 3.4])
>>> H((p1, p2), t=0.5)
(2*(PauliZ(wires=[0]) PauliZ(wires=[1]))) + ((-0.2876553231625218*(PauliX(wires=[0]) PauliX(wires=[1]))) + (1.517961235535459*(PauliY(wires=[0]) PauliY(wires=[1]))))


The time-dependent Hamiltonian can be used within a circuit with `qml.evolve`:

python
def pulse_circuit(params, time):
qml.evolve(H)(params, time)
return qml.expval(qml.PauliX(0) qml.PauliY(1))


Pulse-based circuits can be executed and differentiated on the `default.qubit.jax` simulator using JAX as an interface:

pycon
>>> dev = qml.device("default.qubit.jax", wires=2)
>>> qnode = qml.QNode(pulse_circuit, dev, interface="jax")
>>> params = (p1, p2)
>>> qnode(params, time=0.5)
Array(0.72153819, dtype=float64)
>>> jax.grad(qnode)(params, time=0.5)
(Array(-0.11324919, dtype=float64),
Array([-0.64399616, 0.06326374], dtype=float64))


Check out the [qml.pulse](https://docs.pennylane.ai/en/stable/code/qml_pulse.html) documentation page for more details!

<h4>Special unitary operation 🌞</h4>

* A new operation `qml.SpecialUnitary` has been added, providing access to an arbitrary unitary gate via a parametrization in the Pauli basis.
[(3650)](https://github.com/PennyLaneAI/pennylane/pull/3650) [(#3651)](https://github.com/PennyLaneAI/pennylane/pull/3651) [(#3674)](https://github.com/PennyLaneAI/pennylane/pull/3674)

`qml.SpecialUnitary` creates a unitary that exponentiates a linear combination of all possible Pauli words in lexicographical order — except for the identity operator — for `num_wires` wires, of which there are `4**num_wires - 1`. As its first argument, `qml.SpecialUnitary` takes a list of the `4**num_wires - 1` parameters that are the coefficients of the linear combination.

To see all possible Pauli words for `num_wires` wires, you can use the `qml.ops.qubit.special_unitary.pauli_basis_strings` function:

pycon
>>> qml.ops.qubit.special_unitary.pauli_basis_strings(1) 4**1-1 = 3 Pauli words
['X', 'Y', 'Z']
>>> qml.ops.qubit.special_unitary.pauli_basis_strings(2) 4**2-1 = 15 Pauli words
['IX', 'IY', 'IZ', 'XI', 'XX', 'XY', 'XZ', 'YI', 'YX', 'YY', 'YZ', 'ZI', 'ZX', 'ZY', 'ZZ']


To use `qml.SpecialUnitary`, for example, on a single qubit, we may define

pycon
>>> thetas = np.array([0.2, 0.1, -0.5])
>>> U = qml.SpecialUnitary(thetas, 0)
>>> qml.matrix(U)
array([[ 0.8537127 -0.47537233j, 0.09507447+0.19014893j],
[-0.09507447+0.19014893j, 0.8537127 +0.47537233j]])


A single non-zero entry in the parameters will create a Pauli rotation:

pycon
>>> x = 0.412
>>> theta = x * np.array([1, 0, 0]) The first entry belongs to the Pauli word "X"
>>> su = qml.SpecialUnitary(theta, wires=0)
>>> rx = qml.RX(-2 * x, 0) RX introduces a prefactor -0.5 that has to be compensated
>>> qml.math.allclose(qml.matrix(su), qml.matrix(rx))
True


This operation can be differentiated with hardware-compatible methods like parameter shifts and it supports parameter broadcasting/batching, but not both at the same time. Learn more by visiting the [qml.SpecialUnitary](https://docs.pennylane.ai/en/stable/code/api/pennylane.SpecialUnitary.html) documentation.

<h4>Always differentiable 📈</h4>

* The Hadamard test gradient transform is now available via `qml.gradients.hadamard_grad`. This transform is also available as a differentiation method within `QNode`s. [(3625)](https://github.com/PennyLaneAI/pennylane/pull/3625) [(#3736)](https://github.com/PennyLaneAI/pennylane/pull/3736)

`qml.gradients.hadamard_grad` is a hardware-compatible transform that calculates the gradient of a quantum circuit using the Hadamard test. Note that the device requires an auxiliary wire to calculate the gradient.

pycon
>>> dev = qml.device("default.qubit", wires=2)
>>> qml.qnode(dev)
... def circuit(params):
... qml.RX(params[0], wires=0)
... qml.RY(params[1], wires=0)
... qml.RX(params[2], wires=0)
... return qml.expval(qml.PauliZ(0))
>>> params = np.array([0.1, 0.2, 0.3], requires_grad=True)
>>> qml.gradients.hadamard_grad(circuit)(params)
(tensor(-0.3875172, requires_grad=True),
tensor(-0.18884787, requires_grad=True),
tensor(-0.38355704, requires_grad=True))


This transform can be registered directly as the quantum gradient transform to use during autodifferentiation:

pycon
>>> dev = qml.device("default.qubit", wires=2)
>>> qml.qnode(dev, interface="jax", diff_method="hadamard")
... def circuit(params):
... qml.RX(params[0], wires=0)
... qml.RY(params[1], wires=0)
... qml.RX(params[2], wires=0)
... return qml.expval(qml.PauliZ(0))
>>> params = jax.numpy.array([0.1, 0.2, 0.3])
>>> jax.jacobian(circuit)(params)
Array([-0.3875172 , -0.18884787, -0.38355705], dtype=float32)


* The gradient transform `qml.gradients.spsa_grad` is now registered as a differentiation method for QNodes.
[(3440)](https://github.com/PennyLaneAI/pennylane/pull/3440)

The SPSA gradient transform can now be used implicitly by marking a QNode as differentiable with SPSA. It can be selected via

pycon
>>> dev = qml.device("default.qubit", wires=1)
>>> qml.qnode(dev, interface="jax", diff_method="spsa", h=0.05, num_directions=20)
... def circuit(x):
... qml.RX(x, 0)
... return qml.expval(qml.PauliZ(0))
>>> jax.jacobian(circuit)(jax.numpy.array(0.5))
Array(-0.4792258, dtype=float32, weak_type=True)


The argument `num_directions` determines how many directions of simultaneous perturbation are used and therefore the number of circuit evaluations, up to a prefactor. See the [SPSA gradient transform documentation](https://docs.pennylane.ai/en/stable/code/api/pennylane.gradients.spsa_grad.html) for details. Note: The full SPSA optimization method is already available as `qml.SPSAOptimizer`.

* The default interface is now `auto`. There is no need to specify the interface anymore; it is automatically determined by checking your QNode parameters.
[(3677)](https://github.com/PennyLaneAI/pennylane/pull/3677)[(#3752)](https://github.com/PennyLaneAI/pennylane/pull/3752) [(#3829)](https://github.com/PennyLaneAI/pennylane/pull/3829)

python
import jax
import jax.numpy as jnp

qml.enable_return()
a = jnp.array(0.1)
b = jnp.array(0.2)

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

qml.qnode(dev)
def circuit(a, b):
qml.RY(a, wires=0)
qml.RX(b, wires=1)
qml.CNOT(wires=[0, 1])
return qml.expval(qml.PauliZ(0)), qml.expval(qml.PauliY(1))


pycon
>>> circuit(a, b)
(Array(0.9950042, dtype=float32), Array(-0.19767681, dtype=float32))
>>> jac = jax.jacobian(circuit)(a, b)
>>> jac
(Array(-0.09983341, dtype=float32, weak_type=True), Array(0.01983384, dtype=float32, weak_type=True))


* The JAX-JIT interface now supports higher-order gradient computation with the new return types system.
[(3498)](https://github.com/PennyLaneAI/pennylane/pull/3498)

Here is an example of using JAX-JIT to compute the Hessian of a circuit:

python
import pennylane as qml
import jax
from jax import numpy as jnp

jax.config.update("jax_enable_x64", True)

qml.enable_return()

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

jax.jit
qml.qnode(dev, interface="jax-jit", diff_method="parameter-shift", max_diff=2)
def circuit(a, b):
qml.RY(a, wires=0)
qml.RX(b, wires=1)
return qml.expval(qml.PauliZ(0)), qml.expval(qml.PauliZ(1))

a, b = jnp.array(1.0), jnp.array(2.0)


pycon
>>> jax.hessian(circuit, argnums=[0, 1])(a, b)
(((Array(-0.54030231, dtype=float64, weak_type=True),
Array(0., dtype=float64, weak_type=True)),
(Array(-1.76002563e-17, dtype=float64, weak_type=True),
Array(0., dtype=float64, weak_type=True))),
((Array(0., dtype=float64, weak_type=True),
Array(-1.00700085e-17, dtype=float64, weak_type=True)),
(Array(0., dtype=float64, weak_type=True),
Array(0.41614684, dtype=float64, weak_type=True))))


* The `qchem` workflow has been modified to support both Autograd and JAX frameworks.
[(3458)](https://github.com/PennyLaneAI/pennylane/pull/3458) [(#3462)](https://github.com/PennyLaneAI/pennylane/pull/3462) [(#3495)](https://github.com/PennyLaneAI/pennylane/pull/3495)

The JAX interface is automatically used when the differentiable parameters are JAX objects. Here is an example for computing the Hartree-Fock energy gradients with respect to the atomic coordinates.

python
import pennylane as qml
from pennylane import numpy as np
import jax

symbols = ["H", "H"]
geometry = np.array([[0.0, 0.0, 0.0], [0.0, 0.0, 1.0]])

mol = qml.qchem.Molecule(symbols, geometry)

args = [jax.numpy.array(mol.coordinates)]


pycon
>>> jax.grad(qml.qchem.hf_energy(mol))(*args)
Array([[ 0. , 0. , 0.3650435],
[ 0. , 0. , -0.3650435]], dtype=float64)


* The kernel matrix utility functions in `qml.kernels` are now autodifferentiation-compatible. In addition, they support batching, for example for quantum kernel execution with shot vectors.
[(3742)](https://github.com/PennyLaneAI/pennylane/pull/3742)

This allows for the following:

python
dev = qml.device('default.qubit', wires=2, shots=(100, 100))
qml.qnode(dev)
def circuit(x1, x2):
qml.templates.AngleEmbedding(x1, wires=dev.wires)
qml.adjoint(qml.templates.AngleEmbedding)(x2, wires=dev.wires)
return qml.probs(wires=dev.wires)

kernel = lambda x1, x2: circuit(x1, x2)


We can then compute the kernel matrix on a set of 4 (random) feature vectors `X` but using two sets of 100 shots each via

pycon
>>> X = np.random.random((4, 2))
>>> qml.kernels.square_kernel_matrix(X, kernel)[:, 0]
tensor([[[1. , 0.86, 0.88, 0.92],
[0.86, 1. , 0.75, 0.97],
[0.88, 0.75, 1. , 0.91],
[0.92, 0.97, 0.91, 1. ]],
[[1. , 0.93, 0.91, 0.92],
[0.93, 1. , 0.8 , 1. ],
[0.91, 0.8 , 1. , 0.91],
[0.92, 1. , 0.91, 1. ]]], requires_grad=True)


Note that we have extracted the first probability vector entry for each 100-shot evaluation.

<h4>Smartly decompose Hamiltonian evolution 💯</h4>

* Hamiltonian evolution using `qml.evolve` or `qml.exp` can now be decomposed into operations.
[(3691)](https://github.com/PennyLaneAI/pennylane/pull/3691) [(#3777)](https://github.com/PennyLaneAI/pennylane/pull/3777)

If the time-evolved Hamiltonian is equivalent to another PennyLane operation, then that operation is returned as the decomposition:

pycon
>>> exp_op = qml.evolve(qml.PauliX(0) qml.PauliX(1))
>>> exp_op.decomposition()
[IsingXX((2+0j), wires=[0, 1])]


If the Hamiltonian is a Pauli word, then the decomposition is provided as a `qml.PauliRot` operation:

pycon
>>> qml.evolve(qml.PauliZ(0) qml.PauliX(1)).decomposition()
[PauliRot((2+0j), ZX, wires=[0, 1])]


Otherwise, the Hamiltonian is a linear combination of operators and the Suzuki-Trotter decomposition is used:

pycon
>>> qml.evolve(qml.sum(qml.PauliX(0), qml.PauliY(0), qml.PauliZ(0)), num_steps=2).decomposition()
[RX((1+0j), wires=[0]),
RY((1+0j), wires=[0]),
RZ((1+0j), wires=[0]),
RX((1+0j), wires=[0]),
RY((1+0j), wires=[0]),
RZ((1+0j), wires=[0])]


<h4>Tools for quantum chemistry and other applications 🛠️</h4>

* A new method called `qml.qchem.givens_decomposition` has been added, which decomposes a unitary into a sequence of Givens rotation gates with phase shifts and a diagonal phase matrix.
[(3573)](https://github.com/PennyLaneAI/pennylane/pull/3573)

python
unitary = np.array([[ 0.73678+0.27511j, -0.5095 +0.10704j, -0.06847+0.32515j],
[-0.21271+0.34938j, -0.38853+0.36497j, 0.61467-0.41317j],
[ 0.41356-0.20765j, -0.00651-0.66689j, 0.32839-0.48293j]])

phase_mat, ordered_rotations = qml.qchem.givens_decomposition(unitary)


pycon
>>> phase_mat
tensor([-0.20604358+0.9785369j , -0.82993272+0.55786114j,
0.56230612-0.82692833j], requires_grad=True)
>>> ordered_rotations
[(tensor([[-0.65087861-0.63937521j, -0.40933651-0.j ],
[-0.29201359-0.28685265j, 0.91238348-0.j ]], requires_grad=True),
(0, 1)),
(tensor([[ 0.47970366-0.33308926j, -0.8117487 -0.j ],
[ 0.66677093-0.46298215j, 0.5840069 -0.j ]], requires_grad=True),
(1, 2)),
(tensor([[ 0.36147547+0.73779454j, -0.57008306-0.j ],
[ 0.2508207 +0.51194108j, 0.82158706-0.j ]], requires_grad=True),
(0, 1))]


* A new template called `qml.BasisRotation` has been added, which performs a basis transformation defined by a set of fermionic ladder operators.
[(3573)](https://github.com/PennyLaneAI/pennylane/pull/3573)

python
import pennylane as qml
from pennylane import numpy as np

V = np.array([[ 0.53672126+0.j , -0.1126064 -2.41479668j],
[-0.1126064 +2.41479668j, 1.48694623+0.j ]])
eigen_vals, eigen_vecs = np.linalg.eigh(V)
umat = eigen_vecs.T
wires = range(len(umat))
def circuit():
qml.adjoint(qml.BasisRotation(wires=wires, unitary_matrix=umat))
for idx, eigenval in enumerate(eigen_vals):
qml.RZ(eigenval, wires=[idx])
qml.BasisRotation(wires=wires, unitary_matrix=umat)


pycon
>>> circ_unitary = qml.matrix(circuit)()
>>> np.round(circ_unitary/circ_unitary[0][0], 3)
tensor([[ 1. -0.j , -0. +0.j , -0. +0.j , -0. +0.j ],
[-0. +0.j , -0.516-0.596j, -0.302-0.536j, -0. +0.j ],
[-0. +0.j , 0.35 +0.506j, -0.311-0.724j, -0. +0.j ],
[-0. +0.j , -0. +0.j , -0. +0.j , -0.438+0.899j]], requires_grad=True)


* A new function called `qml.qchem.load_basisset` has been added to extract `qml.qchem` basis set data from the Basis Set Exchange library.
[(3363)](https://github.com/PennyLaneAI/pennylane/pull/3363)

* A new function called `qml.math.max_entropy` has been added to compute the maximum entropy of a quantum state.
[(3594)](https://github.com/PennyLaneAI/pennylane/pull/3594)

* A new template called `qml.TwoLocalSwapNetwork` has been added that implements a canonical 2-complete linear (2-CCL) swap network described in [arXiv:1905.05118](https://arxiv.org/abs/1905.05118).
[(3447)](https://github.com/PennyLaneAI/pennylane/pull/3447)

python3
dev = qml.device('default.qubit', wires=5)
weights = np.random.random(size=qml.templates.TwoLocalSwapNetwork.shape(len(dev.wires)))
acquaintances = lambda index, wires, param: (qml.CRY(param, wires=index)
if np.abs(wires[0]-wires[1]) else qml.CRZ(param, wires=index))
qml.qnode(dev)
def swap_network_circuit():
qml.templates.TwoLocalSwapNetwork(dev.wires, acquaintances, weights, fermionic=False)
return qml.state()


pycon
>>> print(weights)
tensor([0.20308242, 0.91906199, 0.67988804, 0.81290256, 0.08708985,
0.81860084, 0.34448344, 0.05655892, 0.61781612, 0.51829044], requires_grad=True)
>>> print(qml.draw(swap_network_circuit, expansion_strategy = 'device')())
0: ─╭●────────╭SWAP─────────────────╭●────────╭SWAP─────────────────╭●────────╭SWAP─┤ State
1: ─╰RY(0.20)─╰SWAP─╭●────────╭SWAP─╰RY(0.09)─╰SWAP─╭●────────╭SWAP─╰RY(0.62)─╰SWAP─┤ State
2: ─╭●────────╭SWAP─╰RY(0.68)─╰SWAP─╭●────────╭SWAP─╰RY(0.34)─╰SWAP─╭●────────╭SWAP─┤ State
3: ─╰RY(0.92)─╰SWAP─╭●────────╭SWAP─╰RY(0.82)─╰SWAP─╭●────────╭SWAP─╰RY(0.52)─╰SWAP─┤ State
4: ─────────────────╰RY(0.81)─╰SWAP─────────────────╰RY(0.06)─╰SWAP─────────────────┤ State


<h3>Improvements 🛠</h3>

<h4>Pulse programming</h4>

* A new function called `qml.pulse.pwc` has been added as a convenience function for defining a `qml.pulse.ParametrizedHamiltonian`. This function can be used to create a callable coefficient by setting the timespan over which the function should be non-zero. The resulting callable can be passed an array of parameters and a time.
[(3645)](https://github.com/PennyLaneAI/pennylane/pull/3645)

pycon
>>> timespan = (2, 4)
>>> f = qml.pulse.pwc(timespan)
>>> f * qml.PauliX(0)
ParametrizedHamiltonian: terms=1


The `params` array will be used as bin values evenly distributed over the timespan, and the parameter `t` will determine which of the bins is returned.

pycon
>>> f(params=[1.2, 2.3, 3.4, 4.5], t=3.9)
DeviceArray(4.5, dtype=float32)
>>> f(params=[1.2, 2.3, 3.4, 4.5], t=6) zero outside the range (2, 4)
DeviceArray(0., dtype=float32)


* A new function called`qml.pulse.pwc_from_function` has been added as a decorator for defining a `qml.pulse.ParametrizedHamiltonian`. This function can be used to decorate a function and create a piecewise constant approximation of it.
[(3645)](https://github.com/PennyLaneAI/pennylane/pull/3645)

pycon
>>> qml.pulse.pwc_from_function((2, 4), num_bins=10)
... def f1(p, t):
... return p * t


The resulting function approximates the same of `p**2 * t` on the interval `t=(2, 4)` in 10 bins, and returns zero outside the interval.

pycon
t=2 and t=2.1 are within the same bin
>>> f1(3, 2), f1(3, 2.1)
(DeviceArray(6., dtype=float32), DeviceArray(6., dtype=float32))
next bin
>>> f1(3, 2.2)
DeviceArray(6.6666665, dtype=float32)
outside the interval t=(2, 4)
>>> f1(3, 5)
DeviceArray(0., dtype=float32)


* Add `ParametrizedHamiltonianPytree` class, which is a pytree jax object representing a parametrized Hamiltonian, where the matrix computation is delayed to improve performance.
[(3779)](https://github.com/PennyLaneAI/pennylane/pull/3779)

<h4>Operations and batching</h4>

* The function `qml.dot` has been updated to compute the dot product between a vector and a list of operators.
[(3586)](https://github.com/PennyLaneAI/pennylane/pull/3586)

pycon
>>> coeffs = np.array([1.1, 2.2])
>>> ops = [qml.PauliX(0), qml.PauliY(0)]
>>> qml.dot(coeffs, ops)
(1.1*(PauliX(wires=[0]))) + (2.2*(PauliY(wires=[0])))
>>> qml.dot(coeffs, ops, pauli=True)
1.1 * X(0) + 2.2 * Y(0)


* `qml.evolve` returns the evolution of an `Operator` or a `ParametrizedHamiltonian`.
[(3617)](https://github.com/PennyLaneAI/pennylane/pull/3617) [(#3706)](https://github.com/PennyLaneAI/pennylane/pull/3706)

* `qml.ControlledQubitUnitary` now inherits from `qml.ops.op_math.ControlledOp`, which defines `decomposition`, `expand`, and `sparse_matrix` rather than raising an error.
[(3450)](https://github.com/PennyLaneAI/pennylane/pull/3450)

* Parameter broadcasting support has been added for the `qml.ops.op_math.Controlled` class if the base operator supports broadcasting.
[(3450)](https://github.com/PennyLaneAI/pennylane/pull/3450)

* The `qml.generator` function now checks if the generator is Hermitian, rather than whether it is a subclass of `Observable`. This allows it to return valid generators from `SymbolicOp` and `CompositeOp` classes.
[(3485)](https://github.com/PennyLaneAI/pennylane/pull/3485)

* The `qml.equal` function has been extended to compare `Prod` and `Sum` operators.
[(3516)](https://github.com/PennyLaneAI/pennylane/pull/3516)

* `qml.purity` has been added as a measurement process for purity
[(3551)](https://github.com/PennyLaneAI/pennylane/pull/3551)

* In-place inversion has been removed for qutrit operations in preparation for the removal of in-place inversion.
[(3566)](https://github.com/PennyLaneAI/pennylane/pull/3566)

* The `qml.utils.sparse_hamiltonian` function has been moved to thee `qml.Hamiltonian.sparse_matrix` method.
[(3585)](https://github.com/PennyLaneAI/pennylane/pull/3585)

* The `qml.pauli.PauliSentence.operation()` method has been improved to avoid instantiating an `SProd` operator when the coefficient is equal to 1.
[(3595)](https://github.com/PennyLaneAI/pennylane/pull/3595)

* Batching is now allowed in all `SymbolicOp` operators, which include `Exp`, `Pow` and `SProd`.
[(3597)](https://github.com/PennyLaneAI/pennylane/pull/3597)

* The `Sum` and `Prod` operations now have broadcasted operands.
[(3611)](https://github.com/PennyLaneAI/pennylane/pull/3611)

* The XYX single-qubit unitary decomposition has been implemented.
[(3628)](https://github.com/PennyLaneAI/pennylane/pull/3628)

* All dunder methods now return `NotImplemented`, allowing the right dunder method (e.g. `__radd__`) of the other class to be called.
[(3631)](https://github.com/PennyLaneAI/pennylane/pull/3631)

* The `qml.GellMann` operators now include their index when displayed.
[(3641)](https://github.com/PennyLaneAI/pennylane/pull/3641)

* `qml.ops.ctrl_decomp_zyz` has been added to compute the decomposition of a controlled single-qubit operation given a single-qubit operation and the control wires.
[(3681)](https://github.com/PennyLaneAI/pennylane/pull/3681)

* `qml.pauli.is_pauli_word` now supports `Prod` and `SProd` operators, and it returns `False` when a `Hamiltonian` contains more than one term.
[(3692)](https://github.com/PennyLaneAI/pennylane/pull/3692)

* `qml.pauli.pauli_word_to_string` now supports `Prod`, `SProd` and `Hamiltonian` operators.
[(3692)](https://github.com/PennyLaneAI/pennylane/pull/3692)

* `qml.ops.op_math.Controlled` can now decompose single qubit target operations more effectively using the ZYZ decomposition.
[(3726)](https://github.com/PennyLaneAI/pennylane/pull/3726)

* The `qml.qchem.Molecule` class raises an error when the molecule has an odd number of electrons or when the spin multiplicity is not 1.
[(3748)](https://github.com/PennyLaneAI/pennylane/pull/3748)

* `qml.qchem.basis_rotation` now accounts for spin, allowing it to perform Basis Rotation Groupings for molecular hamiltonians.
[(3714)](https://github.com/PennyLaneAI/pennylane/pull/3714)[(#3774)](https://github.com/PennyLaneAI/pennylane/pull/3774)

* The gradient transforms work for the new return type system with non-trivial classical jacobians.
[(3776)](https://github.com/PennyLaneAI/pennylane/pull/3776)

* The `default.mixed` device has received a performance improvement for multi-qubit operations. This also allows to apply channels that act on more than seven qubits, which was not possible before.
[(3584)](https://github.com/PennyLaneAI/pennylane/pull/3584)

* `qml.dot` now groups coefficients together.
[(3691)](https://github.com/PennyLaneAI/pennylane/pull/3691)

pycon
>>> qml.dot(coeffs=[2, 2, 2], ops=[qml.PauliX(0), qml.PauliY(1), qml.PauliZ(2)])
2*(PauliX(wires=[0]) + PauliY(wires=[1]) + PauliZ(wires=[2]))


* `qml.generator` now supports operators with `Sum` and `Prod` generators.
[(3691)](https://github.com/PennyLaneAI/pennylane/pull/3691)

* The `Sum._sort` method now takes into account the name of the operator when sorting.
[(3691)](https://github.com/PennyLaneAI/pennylane/pull/3691)

* A new tape transform called `qml.transforms.sign_expand` has been added. It implements the optimal decomposition of a fast forwardable Hamiltonian that minimizes the variance of its estimator in the Single-Qubit-Measurement from [arXiv:2207.09479](https://arxiv.org/abs/2207.09479).
[(2852)](https://github.com/PennyLaneAI/pennylane/pull/2852)

<h4>Differentiability and interfaces</h4>

* The `qml.math` module now also contains a submodule for fast Fourier transforms, `qml.math.fft`.
[(1440)](https://github.com/PennyLaneAI/pennylane/pull/1440)

The submodule in particular provides differentiable versions of the following functions, available in all common interfaces for PennyLane

* [fft](https://numpy.org/doc/stable/reference/generated/numpy.fft.fft.html)
* [ifft](https://numpy.org/doc/stable/reference/generated/numpy.fft.ifft.html)
* [fft2](https://numpy.org/doc/stable/reference/generated/numpy.fft.fft2.html)
* [ifft2](https://numpy.org/doc/stable/reference/generated/numpy.fft.ifft2.html)

Note that the output of the derivative of these functions may differ when used with complex-valued inputs, due to different conventions on complex-valued derivatives.

* Validation has been added on gradient keyword arguments when initializing a QNode — if unexpected keyword arguments are passed, a `UserWarning` is raised. A list of the current expected gradient function keyword arguments can be accessed via `qml.gradients.SUPPORTED_GRADIENT_KWARGS`.
[(3526)](https://github.com/PennyLaneAI/pennylane/pull/3526)

* The `numpy` version has been constrained to `<1.24`.
[(3563)](https://github.com/PennyLaneAI/pennylane/pull/3563)

* Support for two-qubit unitary decomposition with JAX-JIT has been added.
[(3569)](https://github.com/PennyLaneAI/pennylane/pull/3569)

* `qml.math.size` now supports PyTorch tensors.
[(3606)](https://github.com/PennyLaneAI/pennylane/pull/3606)

* Most quantum channels are now fully differentiable on all interfaces.
[(3612)](https://github.com/PennyLaneAI/pennylane/pull/3612)

* `qml.math.matmul` now supports PyTorch and Autograd tensors.
[(3613)](https://github.com/PennyLaneAI/pennylane/pull/3613)

* Add `qml.math.detach`, which detaches a tensor from its trace. This stops automatic gradient computations.
[(3674)](https://github.com/PennyLaneAI/pennylane/pull/3674)

* Add `typing.TensorLike` type.
[(3675)](https://github.com/PennyLaneAI/pennylane/pull/3675)

* `qml.QuantumMonteCarlo` template is now JAX-JIT compatible when passing `jax.numpy` arrays to the template.
[(3734)](https://github.com/PennyLaneAI/pennylane/pull/3734)

* `DefaultQubitJax` now supports evolving the state vector when executing `qml.pulse.ParametrizedEvolution` gates.
[(3743)](https://github.com/PennyLaneAI/pennylane/pull/3743)

* `SProd.sparse_matrix` now supports interface-specific variables with a single element as the `scalar`.
[(3770)](https://github.com/PennyLaneAI/pennylane/pull/3770)

* Added `argnum` argument to `metric_tensor`. By passing a sequence of indices referring to trainable tape parameters, the metric tensor is only computed with respect to these parameters. This reduces the number of tapes that have to be run.
[(3587)](https://github.com/PennyLaneAI/pennylane/pull/3587)

* The parameter-shift derivative of variances saves a redundant evaluation of the corresponding unshifted expectation value tape, if possible
[(3744)](https://github.com/PennyLaneAI/pennylane/pull/3744)

<h4>Next generation device API</h4>

* The `apply_operation` single-dispatch function is added to `devices/qubit` that applies an operation to a state and returns a new state.
[(3637)](https://github.com/PennyLaneAI/pennylane/pull/3637)

* The `preprocess` function is added to `devices/qubit` that validates, expands, and transforms a batch of `QuantumTape` objects to abstract preprocessing details away from the device.
[(3708)](https://github.com/PennyLaneAI/pennylane/pull/3708)

* The `create_initial_state` function is added to `devices/qubit` that returns an initial state for an execution.
[(3683)](https://github.com/PennyLaneAI/pennylane/pull/3683)

* The `simulate` function is added to `devices/qubit` that turns a single quantum tape into a measurement result. The function only supports state based measurements with either no observables or observables with diagonalizing gates. It supports simultaneous measurement of non-commuting observables.
[(3700)](https://github.com/PennyLaneAI/pennylane/pull/3700)

* The `ExecutionConfig` data class has been added.
[(3649)](https://github.com/PennyLaneAI/pennylane/pull/3649)

* The `StatePrep` class has been added as an interface that state-prep operators must implement.
[(3654)](https://github.com/PennyLaneAI/pennylane/pull/3654)

* `qml.QubitStateVector` now implements the `StatePrep` interface.
[(3685)](https://github.com/PennyLaneAI/pennylane/pull/3685)

* `qml.BasisState` now implements the `StatePrep` interface.
[(3693)](https://github.com/PennyLaneAI/pennylane/pull/3693)

* New Abstract Base Class for devices `Device` is added to the `devices.experimental` submodule. This interface is still in experimental mode and not integrated with the rest of pennylane.
[(3602)](https://github.com/PennyLaneAI/pennylane/pull/3602)

<h4>Other improvements</h4>

* Writing Hamiltonians to a file using the `qml.data` module has been improved by employing a condensed writing format.
[(3592)](https://github.com/PennyLaneAI/pennylane/pull/3592)

* Lazy-loading in the `qml.data.Dataset.read()` method is more universally supported.
[(3605)](https://github.com/PennyLaneAI/pennylane/pull/3605)

* The `qchem.Molecule` class raises an error when the molecule has an odd number of electrons or when the spin multiplicity is not 1.
[(3748)](https://github.com/PennyLaneAI/pennylane/pull/3748)

* `qml.draw` and `qml.draw_mpl` have been updated to draw any quantum function, which allows for visualizing only part of a complete circuit/QNode.
[(3760)](https://github.com/PennyLaneAI/pennylane/pull/3760)

* The string representation of a Measurement Process now includes the `_eigvals` property if it is set.
[(3820)](https://github.com/PennyLaneAI/pennylane/pull/3820)

<h3>Breaking changes 💔</h3>

* The argument `mode` in execution has been replaced by the boolean `grad_on_execution` in the new execution pipeline.
[(3723)](https://github.com/PennyLaneAI/pennylane/pull/3723)

* `qml.VQECost` has been removed.
[(3735)](https://github.com/PennyLaneAI/pennylane/pull/3735)

* The default interface is now `auto`.
[(3677)](https://github.com/PennyLaneAI/pennylane/pull/3677)[(#3752)](https://github.com/PennyLaneAI/pennylane/pull/3752)[(#3829)](https://github.com/PennyLaneAI/pennylane/pull/3829)

The interface is determined during the QNode call instead of the initialization. It means that the `gradient_fn` and `gradient_kwargs` are only defined on the QNode at the beginning of the call. Moreover, without specifying the interface it is not possible to guarantee that the device will not be changed during the call if you are using backprop (such as `default.qubit` changing to `default.qubit.jax`) whereas before it was happening at initialization.

* The tape method `get_operation` can also now return the operation index in the tape, and it can be activated by setting the `return_op_index` to `True`: `get_operation(idx, return_op_index=True)`. It will become the default in version `0.30`.
[(3667)](https://github.com/PennyLaneAI/pennylane/pull/3667)

* `Operation.inv()` and the `Operation.inverse` setter have been removed. Please use `qml.adjoint` or `qml.pow` instead.
[(3618)](https://github.com/PennyLaneAI/pennylane/pull/3618)

For example, instead of

pycon
>>> qml.PauliX(0).inv()


use

pycon
>>> qml.adjoint(qml.PauliX(0))


* The `Operation.inverse` property has been removed completely.
[(3725)](https://github.com/PennyLaneAI/pennylane/pull/3725)

* The target wires of `qml.ControlledQubitUnitary` are no longer available via `op.hyperparameters["u_wires"]`. Instead, they can be accesses via `op.base.wires` or `op.target_wires`.
[(3450)](https://github.com/PennyLaneAI/pennylane/pull/3450)

* The tape constructed by a `QNode` is no longer queued to surrounding contexts.
[(3509)](https://github.com/PennyLaneAI/pennylane/pull/3509)

* Nested operators like `Tensor`, `Hamiltonian`, and `Adjoint` now remove their owned operators from the queue instead of updating their metadata to have an `"owner"`.
[(3282)](https://github.com/PennyLaneAI/pennylane/pull/3282)

* `qml.qchem.scf`, `qml.RandomLayers.compute_decomposition`, and `qml.Wires.select_random` now use local random number generators instead of global random number generators. This may lead to slightly different random numbers and an independence of the results from the global random number generation state. Please provide a seed to each individual function instead if you want controllable results.
[(3624)](https://github.com/PennyLaneAI/pennylane/pull/3624)

* `qml.transforms.measurement_grouping` has been removed. Users should use `qml.transforms.hamiltonian_expand` instead.
[(3701)](https://github.com/PennyLaneAI/pennylane/pull/3701)

* `op.simplify()` for operators which are linear combinations of Pauli words will use a builtin Pauli representation to more efficiently compute the simplification of the operator.
[(3481)](https://github.com/PennyLaneAI/pennylane/pull/3481)

* All `Operator`'s input parameters that are lists are cast into vanilla numpy arrays.
[(3659)](https://github.com/PennyLaneAI/pennylane/pull/3659)

* `QubitDevice.expval` no longer permutes an observable's wire order before passing it to `QubitDevice.probability`. The associated downstream changes for `default.qubit` have been made, but this may still affect expectations for other devices that inherit from `QubitDevice` and override `probability` (or any other helper functions that take a wire order such as `marginal_prob`, `estimate_probability` or `analytic_probability`).
[(3753)](https://github.com/PennyLaneAI/pennylane/pull/3753)

<h3>Deprecations 👋</h3>

* `qml.utils.sparse_hamiltonian` function has been deprecated, and usage will now raise a warning. Instead, one should use the `qml.Hamiltonian.sparse_matrix` method.
[(3585)](https://github.com/PennyLaneAI/pennylane/pull/3585)

* The `collections` module has been deprecated.
[(3686)](https://github.com/PennyLaneAI/pennylane/pull/3686)
[(3687)](https://github.com/PennyLaneAI/pennylane/pull/3687)

* `qml.op_sum` has been deprecated. Users should use `qml.sum` instead.
[(3686)](https://github.com/PennyLaneAI/pennylane/pull/3686)

* The use of `Evolution` directly has been deprecated. Users should use `qml.evolve` instead. This new function changes the sign of the given parameter.
[(3706)](https://github.com/PennyLaneAI/pennylane/pull/3706)

* Use of `qml.dot` with a `QNodeCollection` has been deprecated.
[(3586)](https://github.com/PennyLaneAI/pennylane/pull/3586)

<h3>Documentation 📝</h3>

* Revise note on GPU support in the [circuit introduction](https://docs.pennylane.ai/en/stable/introduction/circuits.html#defining-a-device).
[(3836)](https://github.com/PennyLaneAI/pennylane/pull/3836)

* Make warning about vanilla version of NumPy for differentiation more prominent.
[(3838)](https://github.com/PennyLaneAI/pennylane/pull/3838)

* The documentation for `qml.operation` has been improved.
[(3664)](https://github.com/PennyLaneAI/pennylane/pull/3664)

* The code example in `qml.SparseHamiltonian` has been updated with the correct wire range.
[(3643)](https://github.com/PennyLaneAI/pennylane/pull/3643)

* A hyperlink has been added in the text for a URL in the `qml.qchem.mol_data` docstring.
[(3644)](https://github.com/PennyLaneAI/pennylane/pull/3644)

* A typo was corrected in the documentation for `qml.math.vn_entropy`.
[(3740)](https://github.com/PennyLaneAI/pennylane/pull/3740)

<h3>Bug fixes 🐛</h3>

* Fixed a bug where measuring ``qml.probs`` in the computational basis with non-commuting measurements returned incorrect results. Now an error is raised.
[(3811)](https://github.com/PennyLaneAI/pennylane/pull/3811)

* Fixed a bug in the drawer where nested controlled operations would output the label of the operation being controlled, rather than the control values.
[(3745)](https://github.com/PennyLaneAI/pennylane/pull/3745)

* Fixed a bug in `qml.transforms.metric_tensor` where prefactors of operation generators were taken into account multiple times, leading to wrong outputs for non-standard operations.
[(3579)](https://github.com/PennyLaneAI/pennylane/pull/3579)

* Local random number generators are now used where possible to avoid mutating the global random state.
[(3624)](https://github.com/PennyLaneAI/pennylane/pull/3624)

* The `networkx` version change being broken has been fixed by selectively skipping a `qcut` TensorFlow-JIT test.
[(3609)](https://github.com/PennyLaneAI/pennylane/pull/3609)[(#3619)](https://github.com/PennyLaneAI/pennylane/pull/3619)

* Fixed the wires for the `Y` decomposition in the ZX calculus transform.
[(3598)](https://github.com/PennyLaneAI/pennylane/pull/3598)

* `qml.pauli.PauliWord` is now pickle-able.
[(3588)](https://github.com/PennyLaneAI/pennylane/pull/3588)

* Child classes of `QuantumScript` now return their own type when using `SomeChildClass.from_queue`.
[(3501)](https://github.com/PennyLaneAI/pennylane/pull/3501)

* A typo has been fixed in the calculation and error messages in `operation.py`
[(3536)](https://github.com/PennyLaneAI/pennylane/pull/3536)

* `qml.data.Dataset.write()` now ensures that any lazy-loaded values are loaded before they are written to a file.
[(3605)](https://github.com/PennyLaneAI/pennylane/pull/3605)

* `Tensor._batch_size` is now set to `None` during initialization, copying and `map_wires`.
[(3642)](https://github.com/PennyLaneAI/pennylane/pull/3642)[(#3661)](https://github.com/PennyLaneAI/pennylane/pull/3661)

* `Tensor.has_matrix` is now set to `True`.
[(3647)](https://github.com/PennyLaneAI/pennylane/pull/3647)

* Fixed typo in the example of `qml.IsingZZ` gate decomposition.
[(3676)](https://github.com/PennyLaneAI/pennylane/pull/3676)

* Fixed a bug that made tapes/qnodes using `qml.Snapshot` incompatible with `qml.drawer.tape_mpl`.
[(3704)](https://github.com/PennyLaneAI/pennylane/pull/3704)

* `Tensor._pauli_rep` is set to `None` during initialization and `Tensor.data` has been added to its setter.
[(3722)](https://github.com/PennyLaneAI/pennylane/pull/3722)

* `qml.math.ndim` has been redirected to `jnp.ndim` when using it on a `jax` tensor.
[(3730)](https://github.com/PennyLaneAI/pennylane/pull/3730)

* Implementations of `marginal_prob` (and subsequently, `qml.probs`) now return probabilities with the expected wire order.
[(3753)](https://github.com/PennyLaneAI/pennylane/pull/3753)

This bug affected most probabilistic measurement processes on devices that inherit from `QubitDevice` when the measured wires are out of order with respect to the device wires and 3 or more wires are measured. The assumption was that marginal probabilities would be computed with the device's state and wire order, then re-ordered according to the measurement process wire order. Instead, the re-ordering went in the inverse direction (that is, from measurement process wire order to device wire order). This is now fixed. Note that this only occurred for 3 or more measured wires because this mapping is identical otherwise. More details and discussion of this bug can be found in [the original bug report](https://github.com/PennyLaneAI/pennylane/issues/3741).

* Empty iterables can no longer be returned from QNodes.
[(3769)](https://github.com/PennyLaneAI/pennylane/pull/3769)

* The keyword arguments for `qml.equal` now are used when comparing the observables of a Measurement Process. The eigvals of measurements are only requested if both observables are `None`, saving computational effort.
[(3820)](https://github.com/PennyLaneAI/pennylane/pull/3820)

* Only converts input to `qml.Hermitian` to a numpy array if the input is a list.
[(3820)](https://github.com/PennyLaneAI/pennylane/pull/3820)

<h3>Contributors ✍</h3>

This release contains contributions from (in alphabetical order):

Gian-Luca Anselmetti,
Guillermo Alonso-Linaje,
Juan Miguel Arrazola,
Ikko Ashimine,
Utkarsh Azad,
Miriam Beddig,
Cristian Boghiu,
Thomas Bromley,
Astral Cai,
Isaac De Vlugt,
Olivia Di Matteo,
Lillian M. A. Frederiksen,
Soran Jahangiri,
Korbinian Kottmann,
Christina Lee,
Albert Mitjans Coma,
Romain Moyard,
Mudit Pandey,
Borja Requena,
Matthew Silverman,
Jay Soni,
Antal Száva,
Frederik Wilde,
David Wierichs,
Moritz Willmann.