Repository: PennyLaneAI/pennylane
Pull request #6810 (2025-01-13 03:04:01)

Daily rc sync to master

codecov[bot]: ## [Codecov](https://app.codecov.io/gh/PennyLaneAI/pennylane/pull/6810?dropdown=coverage&src=pr&el=h1&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=PennyLaneAI) Report
All modified and coverable lines are covered by tests :white_check_mark:
> Project coverage is 99.60%. Comparing base [(`9350cb2`)](https://app.codecov.io/gh/PennyLaneAI/pennylane/commit/9350cb29e52701e115f61df974a62eb8fc87f7dc?dropdown=coverage&el=desc&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=PennyLaneAI) to head [(`c7c56e6`)](https://app.codecov.io/gh/PennyLaneAI/pennylane/commit/c7c56e649eb267f6686bb2ecf8e219ea009b6ca3?dropdown=coverage&el=desc&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=PennyLaneAI).

<details><summary>Additional details and impacted files</summary>


```diff
@@           Coverage Diff           @@
##           master    #6810   +/-   ##
=======================================
  Coverage   99.60%   99.60%           
=======================================
  Files         476      476           
  Lines       45222    45237   +15     
=======================================
+ Hits        45045    45060   +15     
  Misses        177      177           
```

</details>

[:umbrella: View full report in Codecov by Sentry](https://app.codecov.io/gh/PennyLaneAI/pennylane/pull/6810?dropdown=coverage&src=pr&el=continue&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=PennyLaneAI).   
:loudspeaker: Have feedback on the report? [Share it here](https://about.codecov.io/codecov-pr-comment-feedback/?utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=PennyLaneAI).

PietropaoloFrisoni: Waiting for double-check on the rendered changelog from @isaacdevlugt before approving :+1: 

Patch:
diff --git a/doc/code/qml_noise.rst b/doc/code/qml_noise.rst
index f8c30d7bd..adba65378 100644
--- a/doc/code/qml_noise.rst
+++ b/doc/code/qml_noise.rst
@@ -22,7 +22,7 @@ noise-related metadata can also be supplied to construct a noise model using:
     ~NoiseModel
 
 Each conditional in the ``model_map`` (and ``meas_map``) evaluates the gate operations 
-(and terminal measurments) in the quantum circuit based on some condition of its attributes
+(and terminal measurements) in the quantum circuit based on some condition of its attributes
 (e.g., type, parameters, wires, etc.) and uses the corresponding callable to apply the
 noise operations, using the user-provided metadata (e.g., hardware topologies or relaxation
 times), whenever the condition is true. A noise model, once built, can be attached
diff --git a/doc/development/autograph.rst b/doc/development/autograph.rst
index 9fc376aff..e4455b3d2 100644
--- a/doc/development/autograph.rst
+++ b/doc/development/autograph.rst
@@ -80,7 +80,7 @@ Python control flow:
 
         return qml.expval(qml.PauliZ(0) + qml.PauliZ(3))
 
-While this function cannot be captured directly because there is control flow that depends on the function's inputs' values—the inputs are treated as JAX tracers at capture time, which don't have concrete values—it can be captured by converting to native PennyLane syntax
+While this function cannot be captured directly because there is control flow that depends on the values of the function's inputs (the inputs are treated as JAX tracers at capture time, which don't have concrete values) it can be captured by converting to native PennyLane syntax
 via AutoGraph. This is the default behaviour of :func:`~.autograph.make_plxpr`.
 
 >>> weights = jnp.linspace(-1, 1, 20).reshape([5, 4])
@@ -351,7 +351,7 @@ For example, using a ``for`` loop with static bounds to index a JAX array is str
 However, indexing within a ``for`` loop with AutoGraph will require that the object indexed is
 a JAX array or dynamic runtime variable.
 
-If the array you are indexing within the for loop is not a JAX array
+If the array you are indexing within the ``for`` loop is not a JAX array
 or dynamic variable, an error will be raised:
 
 >>> @qml.qnode(dev)
@@ -378,7 +378,7 @@ a JAX array:
 >>> eval_jaxpr(plxpr.jaxpr, plxpr.consts)
 [Array(0.99500417, dtype=float64)]
 
-If the object you are indexing **cannot** be converted to a JAX array, it is not possible for AutoGraph to capture this for loop.
+If the object you are indexing **cannot** be converted to a JAX array, it is not possible for AutoGraph to capture this ``for`` loop.
 
 If you are updating elements of the array, this must be done using the JAX ``.at`` and ``.set`` syntax.
 
@@ -440,7 +440,7 @@ However, like with conditionals, a similar restriction applies: variables
 which are updated across iterations of the loop must have a JAX compilable
 type (Booleans, Python numeric types, and JAX arrays).
 
-You can also utilize temporary variables within a for loop:
+You can also utilize temporary variables within a ``for`` loop:
 
 >>> def f(x):
 ...     for y in [0, 4, 5]:
@@ -520,7 +520,7 @@ To allow AutoGraph conversion to work in this case, simply convert the list to a
 >>> eval_jaxpr(plxpr.jaxpr, plxpr.consts)
 [Array(0.99500417, dtype=float64)]
 
-If the object you are indexing **cannot** be converted to a JAX array, it is not possible for AutoGraph to capture this for loop.
+If the object you are indexing **cannot** be converted to a JAX array, it is not possible for AutoGraph to capture this ``while`` loop.
 
 If you are updating elements of the array, this must be done using the JAX ``.at`` and ``.set`` syntax.
 
diff --git a/doc/development/deprecations.rst b/doc/development/deprecations.rst
index 5e8f02fe5..fd1c5051e 100644
--- a/doc/development/deprecations.rst
+++ b/doc/development/deprecations.rst
@@ -47,15 +47,6 @@ Pending deprecations
   - Deprecated in v0.40
   - Will be removed in v0.41
 
-  - Deprecated in v0.39
-  - Will be removed in v0.40
-  
-* The ``QubitStateVector`` template is deprecated.
-  Instead, use ``StatePrep``.
-
-  - Deprecated in v0.39
-  - Will be removed in v0.40
-
 * ``op.ops`` and ``op.coeffs`` for ``Sum`` and ``Prod`` will be removed in the future. Use
   :meth:`~.Operator.terms` instead.
 
@@ -70,7 +61,6 @@ Pending deprecations
   values with a bit string. In the future, it will no longer accepts strings as control values.
 
   - Deprecated in v0.36
-  - Will be removed in v0.37
 
 Completed removal of legacy operator arithmetic
 -----------------------------------------------
diff --git a/doc/development/plugins.rst b/doc/development/plugins.rst
index ac9574d46..4a15f2c75 100644
--- a/doc/development/plugins.rst
+++ b/doc/development/plugins.rst
@@ -62,7 +62,7 @@ For example:
 
 This execute method works in tandem with the optional :meth:`Device.preprocess_transforms <pennylane.devices.Device.preprocess_transforms>`
 and :meth:`Device.setup_execution_config`, described below in more detail. Preprocessing transforms
-turns generic circuits into ones supported by the device, or raises an error if the circuit is invalid.
+turns generic circuits into ones supported by the device or raises an error if the circuit is invalid.
 Execution produces numerical results from those supported circuits.
 
 In a more minimal example, for any initial batch of quantum tapes and a config object, we expect to be able to do:
@@ -376,7 +376,7 @@ Wires
 Devices can now either:
 
 1) Strictly use wires provided by the user on initialization: ``device(name, wires=wires)``
-2) Infer the number and ordering of wires provided by the submitted circuit.
+2) Infer the number and order of wires provided by the submitted circuit
 3) Strictly require specific wire labels
 
 Option 2 allows workflows to change the number and labeling of wires over time, but sometimes users want
@@ -434,18 +434,20 @@ The execution config stores two kinds of information:
 
 Device options are any device specific options used to configure the behavior of an execution. For
 example, ``default.qubit`` has ``max_workers``, ``rng``, and ``prng_key``. ``default.tensor`` has
-``contract``, ``cutoff``, ``dtype``, ``method``, and ``max_bond_dim``. These options are often set
+``contract``, ``contraction_optimizer``, ``cutoff``, ``c_dtype``, ``local_simplify``, ``method``, and ``max_bond_dim``. These options are often set
 with default values on initialization. These values should be placed into the ``ExecutionConfig.device_options``
 dictionary in :meth:`~.devices.Device.setup_execution_config`. Note that we do provide a default
 implementation of this method, but you will most likely need to override it yourself.
 
->>> dev = qml.device('default.tensor', wires=2, max_bond_dim=4, contract="nonlocal", dtype=np.complex64)
+>>> dev = qml.device('default.tensor', wires=2, max_bond_dim=4, contract="nonlocal", c_dtype=np.complex64)
 >>> dev.setup_execution_config().device_options
 {'contract': 'nonlocal',
- 'cutoff': 1.1920929e-07,
- 'dtype': numpy.complex64,
- 'method': 'mps',
- 'max_bond_dim': 4}
+ 'contraction_optimizer': 'auto-hq',
+ 'cutoff': None,
+ 'c_dtype': numpy.complex64,
+ 'local_simplify': 'ADCRS',
+ 'max_bond_dim': 4,
+ 'method': 'mps'}
 
 Even if the property is stored as an attribute on the device, execution should pull the value of
 these properties from the config instead of from the device instance. While not yet integrated at
diff --git a/doc/releases/changelog-0.40.0.md b/doc/releases/changelog-0.40.0.md
index 7d9707882..bb9cb7cd3 100644
--- a/doc/releases/changelog-0.40.0.md
+++ b/doc/releases/changelog-0.40.0.md
@@ -6,61 +6,215 @@
 
 <h4>Efficient state preparation methods 🦾</h4>
 
-* Added new ``MPSPrep`` template to prepare quantum states in tensor simulators.
+* State preparation tailored for matrix product states (MPS) is now supported with 
+  :class:`qml.MPSPrep <pennylane.MPSPrep>` on the `lightning.tensor` device.
   [(#6431)](https://github.com/PennyLaneAI/pennylane/pull/6431)
 
-* Users can prepare a linear combination of basis states using `qml.Superposition`.
+  Given a list of :math:`n` tensors that represents an MPS, :math:`[A^{(0)}, ..., A^{(n-1)}]`, 
+  :class:`qml.MPSPrep <pennylane.MPSPrep>` lets you directly inject the MPS into a QNode as the initial 
+  state of the circuit without any need for pre-processing. The first and last tensors in the list 
+  must be rank-2, while all intermediate tensors should be rank-3.
+
+  ```python
+  import pennylane as qml
+  import numpy as np
+
+  mps = [
+      np.array([[0.0, 0.107], [0.994, 0.0]]),
+      np.array(
+          [
+              [[0.0, 0.0, 0.0, -0.0], [1.0, 0.0, 0.0, -0.0]],
+              [[0.0, 1.0, 0.0, -0.0], [0.0, 0.0, 0.0, -0.0]],
+          ]
+      ),
+      np.array(
+          [
+              [[-1.0, 0.0], [0.0, 0.0]],
+              [[0.0, 0.0], [0.0, 1.0]],
+              [[0.0, -1.0], [0.0, 0.0]],
+              [[0.0, 0.0], [1.0, 0.0]],
+          ]
+      ),
+      np.array([[-1.0, -0.0], [-0.0, -1.0]]),
+  ]
+
+  dev = qml.device("lightning.tensor", wires = [0, 1, 2, 3])
+  @qml.qnode(dev)
+  def circuit():
+      qml.MPSPrep(mps, wires = [0,1,2])
+      return qml.state()
+  ```
+
+  ```pycon
+  >>> print(circuit())
+  [ 0.    +0.j  0.    +0.j  0.    +0.j -0.1066+0.j  0.    +0.j  0.    +0.j
+    0.    +0.j  0.    +0.j  0.    +0.j  0.    +0.j  0.    +0.j  0.    +0.j
+    0.9943+0.j  0.    +0.j  0.    +0.j  0.    +0.j]
+  ```
+
+  At this time, :class:`qml.MPSPrep <pennylane.MPSPrep>` is only supported on the `lightning.tensor` device.
+
+* Custom-made state preparation for linear combinations of quantum states is now available with 
+  :class:`qml.Superposition <pennylane.Superposition>`.
   [(#6670)](https://github.com/PennyLaneAI/pennylane/pull/6670)
 
+  Given a list of :math:`m` coefficients :math:`c_i` and basic states :math:`|b_i\rangle`, 
+  :class:`qml.Superposition <pennylane.Superposition>` prepares 
+  :math:`|\phi\rangle = \sum_i^m c_i |b_i\rangle`. Here is a simple example showing how to use 
+  :class:`qml.Superposition <pennylane.Superposition>` to prepare 
+  :math:`\tfrac{1}{\sqrt{2}} |00\rangle + \tfrac{1}{\sqrt{2}} |10\rangle`.
+
   ```python
   coeffs = np.array([0.70710678, 0.70710678])
   basis =  np.array([[0, 0], [1, 0]])
 
-  @qml.qnode(qml.device('default.qubit', wires=2))
+  @qml.qnode(qml.device('default.qubit'))
   def circuit():
-      qml.Superposition(coeffs, basis)
+      qml.Superposition(coeffs, basis, wires=[0, 1], work_wire=[2])
       return qml.state()
   ```
+
   ```
   >>> circuit()
-  tensor([0.70710678+0.j, 0.+0.j, 0.70710678+0.j, 0.+0.j], requires_grad=True)
+  Array([0.7071068 +0.j, 0.        +0.j, 0.        +0.j, 0.        +0.j,
+         0.70710677+0.j, 0.        +0.j, 0.        +0.j, 0.        +0.j],      dtype=complex64)
   ```
 
-  This template is also JAX-jit compatible!
+  Note that specification of one `work_wire` is required.
 
 <h4>Enhanced QSVT functionality 🤩</h4>
 
-* New functionality to calculate angles for QSP and QSVT has been added. This includes the function `qml.poly_to_angles`
-  to obtain angles directly and the function `qml.transform_angles` to convert angles from one subroutine to another.
+* New functionality to calculate and convert phase angles for QSP and QSVT has been added
+  with :func:`qml.poly_to_angles <pennylane.poly_to_angles>` and 
+  :func:`qml.transform_angles <pennylane.transform_angles>`.
   [(#6483)](https://github.com/PennyLaneAI/pennylane/pull/6483)
 
-* The `qml.qsvt` function has been improved to be more user-friendly. Old functionality is moved to `qml.qsvt_legacy`
-  and it will be deprecated in release v0.40.
-  [(#6520)](https://github.com/PennyLaneAI/pennylane/pull/6520/)
+  The :func:`qml.poly_to_angles <pennylane.poly_to_angles>` function calculates phase angles 
+  directly given polynomial coefficients and the routine in which the angles will be used (`"QSVT"`, 
+  `"QSP"`, or `"GQSP"`):
+  ```pycon
+  >>> poly = [0, 1.0, 0, -1/2, 0, 1/3]
+  >>> qsvt_angles = qml.poly_to_angles(poly, "QSVT")
+  >>> print(qsvt_angles)
+  [-5.49778714  1.57079633  1.57079633  0.5833829   1.61095884  0.74753829]
+  ```
+
+  The :func:`qml.transform_angles <pennylane.transform_angles>` function can be used to convert 
+  angles from one routine to another:
+  ```pycon
+  >>> qsp_angles = np.array([0.2, 0.3, 0.5])
+  >>> qsvt_angles = qml.transform_angles(qsp_angles, "QSP", "QSVT")
+  >>> print(qsvt_angles)
+  [-6.86858347  1.87079633 -0.28539816]
+  ```
+
+* The :func:`qml.qsvt <pennylane.qsvt>` function has been improved to be more user-friendly,
+with enhanced capabilities.
+  [(#6520)](https://github.com/PennyLaneAI/pennylane/pull/6520)
   [(#6693)](https://github.com/PennyLaneAI/pennylane/pull/6693)
 
-* New `qml.GQSP` template has been added to perform Generalized Quantum Signal Processing (GQSP).
-  The functionality `qml.poly_to_angles` has been also extended to support GQSP.
+  Block encoding and phase angle computation are now handled automatically,
+  given a matrix to encode, polynomial coefficients, and a block encoding method
+  (`"prepselprep"`, `"qubitization"`, `"embedding"`, or `"fable"`, all implemented with their 
+  corresponding operators in PennyLane).
+  ```python
+  # P(x) = -x + 0.5 x^3 + 0.5 x^5
+  poly = np.array([0, -1, 0, 0.5, 0, 0.5])
+  hamiltonian = qml.dot([0.3, 0.7], [qml.Z(1), qml.X(1) @ qml.Z(2)])
+  
+  dev = qml.device("default.qubit")
+  @qml.qnode(dev)
+  def circuit():
+      qml.qsvt(hamiltonian, poly, encoding_wires=[0], block_encoding="prepselprep")
+      return qml.state()
+  
+  matrix = qml.matrix(circuit, wire_order=[0, 1, 2])()
+  ```
+  ```pycon
+  >>> print(matrix[:4, :4].real)
+  [[-0.1625  0.     -0.3793  0.    ]
+   [ 0.     -0.1625  0.      0.3793]
+   [-0.3793  0.      0.1625  0.    ]
+   [ 0.      0.3793  0.      0.1625]]
+  ```
+  The old functionality can still be accessed with :func:`qml.qsvt_legacy <pennylane.qsvt_legacy>`.
+
+* A new :class:`qml.GQSP <pennylane.GQSP>` template has been added to perform Generalized Quantum Signal Processing (GQSP).
   [(#6565)](https://github.com/PennyLaneAI/pennylane/pull/6565)
+  Similar to QSVT, GQSP is an algorithm that polynomially transforms an input unitary operator,
+  but with fewer restrictions on the chosen polynomial.
+
+  You can also use :func:`qml.poly_to_angles <pennylane.poly_to_angles>` to obtain angles for GQSP!
+
+  ```python
+  # P(x) = 0.1 + 0.2j x + 0.3 x^2
+  poly = [0.1, 0.2j, 0.3]
+  angles = qml.poly_to_angles(poly, "GQSP")
+  
+  @qml.prod # transforms the qfunc into an Operator
+  def unitary(wires):
+      qml.RX(0.3, wires)
+  
+  dev = qml.device("default.qubit")
+  @qml.qnode(dev)
+  def circuit(angles):
+      qml.GQSP(unitary(wires = 1), angles, control = 0)
+      return qml.state()
+  
+  matrix = qml.matrix(circuit, wire_order=[0, 1])(angles)
+  ```
+  ```pycon
+  >>> print(np.round(matrix,3)[:2, :2])
+  [[0.387+0.198j 0.03 -0.089j]
+  [0.03 -0.089j 0.387+0.198j]]
+  ```
 
 <h4>Generalized Trotter products 🐖</h4>
 
-* Added a function `qml.trotterize` to generalize the Suzuki-Trotter product to arbitrary quantum functions.
+* Trotter products that work on exponentiated operators directly instead of full system hamiltonians 
+  can now be encoded into circuits with the addition of 
+  :class:`qml.TrotterizedQfunc <pennylane.TrotterizedQfunc>` and :func:`qml.trotterize <pennylane.trotterize>`. This
+  allows for custom specification of the first-order expansion of the Suzuki-Trotter product formula
+  and extrapolating it to the :math:`n^{\text{th}}` order.
   [(#6627)](https://github.com/PennyLaneAI/pennylane/pull/6627)
 
+  If the first-order of the Suzuki-Trotter product formula for a given problem is known, 
+  :class:`qml.TrotterizedQfunc <pennylane.TrotterizedQfunc>` and :func:`qml.trotterize <pennylane.trotterize>`
+  let you implement the :math:`n^{\text{th}}`-order product formula while only specifying the 
+  first-order term as a quantum function.
+
   ```python
   def my_custom_first_order_expansion(time, theta, phi, wires, flip):
-    "This is the first order expansion (U_1)."
-    qml.RX(time*theta, wires[0])
-    qml.RY(time*phi, wires[1])
+    qml.RX(time * theta, wires[0])
+    qml.RY(time * phi, wires[1])
     if flip:
         qml.CNOT(wires=wires[:2])
+  ```
+
+  :func:`qml.trotterize <pennylane.trotterize>` requires the quantum function representing the first-order
+  product formula, the number of Trotter steps, and the desired order. It returns a function with 
+  the same call signature as the first-order product formula quantum function:
 
+  ```python
   @qml.qnode(qml.device("default.qubit"))
-  def my_circuit(time, angles, num_trotter_steps):
-      TrotterizedQfunc(
+  def my_circuit(time, theta, phi, num_trotter_steps):
+      qml.trotterize(
+          first_order_expansion,
+          n=num_trotter_steps,
+          order=2,
+      )(time, theta, phi, wires=['a', 'b'], flip=True)
+      return qml.state()
+  ```
+  
+  Alternatively, :class:`qml.TrotterizedQfunc <pennylane.TrotterizedQfunc>` can be used as follows:
+
+  ```python
+  @qml.qnode(qml.device("default.qubit"))
+  def my_circuit(time, theta, phi, num_trotter_steps):
+      qml.TrotterizedQfunc(
           time,
-          *angles,
+          theta,
+          phi,
           qfunc=my_custom_first_order_expansion,
           n=num_trotter_steps,
           order=2,
@@ -69,47 +223,381 @@
       )
       return qml.state()
   ```
+
   ```pycon
   >>> time = 0.1
-  >>> angles = (0.12, -3.45)
-  >>> print(qml.draw(my_circuit, level=3)(time, angles, num_trotter_steps=1))
+  >>> theta, phi = (0.12, -3.45)
+  >>> print(qml.draw(my_circuit, level="device")(time, theta, phi, num_trotter_steps=1))
   a: ──RX(0.01)──╭●─╭●──RX(0.01)──┤  State
   b: ──RY(-0.17)─╰X─╰X──RY(-0.17)─┤  State
   ```
 
+  Both methods produce the same results, but offer different interfaces based on the application or overall
+  preference.
+
 <h4>Bosonic operators 🎈</h4>
 
-* Added `unary_mapping()` function to map `BoseWord` and `BoseSentence` to qubit operators, using unary mapping.
-  [(#6576)](https://github.com/PennyLaneAI/pennylane/pull/6576)
+A new module, :mod:`qml.bose <pennylane.bose>`, has been added to PennyLane that includes support 
+for constructing and manipulating Bosonic operators and converting between Bosonic operators and 
+qubit operators.
 
-* Added `binary_mapping()` function to map `BoseWord` and `BoseSentence` to qubit operators, using standard-binary mapping.
-  [(#6564)](https://github.com/PennyLaneAI/pennylane/pull/6564)
+* Bosonic operators analogous to `qml.FermiWord` and `qml.FermiSentence` are now available with 
+  :class:`qml.BoseWord <pennylane.BoseWord>` and :class:`qml.BoseSentence <pennylane.BoseSentence>`.
+  [(#6518)](https://github.com/PennyLaneAI/pennylane/pull/6518)
+
+  :class:`qml.BoseWord <pennylane.BoseWord>` and :class:`qml.BoseSentence <pennylane.BoseSentence>` 
+  operate similarly to their fermionic counterparts. To create a Bose word, a dictionary 
+  is required as input, where the keys are tuples of boson indices and values are `'+/-'` (denoting 
+  the bosonic creation/annihilation operators). For example, the :math:`b^{\dagger}_0 b_1` can be 
+  constructed as follows.
+
+  ```pycon
+  >>> w = qml.BoseWord({(0, 0) : '+', (1, 1) : '-'})
+  >>> print(w)
+  b⁺(0) b(1)
+  ```
 
-* Added `christiansen_mapping()` function to map `BoseWord` and `BoseSentence` to qubit operators, using christiansen mapping.
+  Multiple Bose words can then be combined to form a Bose sentence:
+
+  ```pycon
+  >>> w1 = qml.BoseWord({(0, 0) : '+', (1, 1) : '-'})
+  >>> w2 = qml.BoseWord({(0, 1) : '+', (1, 2) : '-'})
+  >>> s = qml.BoseSentence({w1 : 1.2, w2: 3.1})
+  >>> print(s)
+  1.2 * b⁺(0) b(1)
+  + 3.1 * b⁺(1) b(2)
+  ```
+
+* Functionality for converting bosonic operators to qubit operators is available with 
+  :func:`qml.unary_mapping <pennylane.unary_mapping>`, :func:`qml.binary_mapping <pennylane.binary_mapping>`, 
+  and :func:`qml.christiansen_mapping <pennylane.christiansen_mapping>`.
   [(#6623)](https://github.com/PennyLaneAI/pennylane/pull/6623)
+  [(#6576)](https://github.com/PennyLaneAI/pennylane/pull/6576)
+  [(#6564)](https://github.com/PennyLaneAI/pennylane/pull/6564)
 
-* Added support for constructing `BoseWord` and `BoseSentence`, similar to `FermiWord` and `FermiSentence`.
-  [(#6518)](https://github.com/PennyLaneAI/pennylane/pull/6518)
+  All three mappings follow the same syntax, where a :class:`qml.BoseWord <pennylane.BoseWord>` or 
+  :class:`qml.BoseSentence <pennylane.BoseSentence>` is required as input.
+
+  ```python
+  >>> w = qml.BoseWord({(0, 0): "+"})
+  >>> qml.binary_mapping(w, n_states=4)
+  0.6830127018922193 * X(0)
+  + -0.1830127018922193 * X(0) @ Z(1)
+  + -0.6830127018922193j * Y(0)
+  + 0.1830127018922193j * Y(0) @ Z(1)
+  + 0.3535533905932738 * X(0) @ X(1)
+  + -0.3535533905932738j * X(0) @ Y(1)
+  + 0.3535533905932738j * Y(0) @ X(1)
+  + (0.3535533905932738+0j) * Y(0) @ Y(1)
+  ```
+
+  Additional fine-tuning is available within each function, such as the maximum number of allowed
+  bosonic states and a tolerance for discarding imaginary parts of the coefficients.
 
-<h4>Construct vibrational Hamiltonians 🫨</h4>
+<h4>Construct vibrational Hamiltonians 🔨</h4>
 
-* Added submodule for calculating vibrational Hamiltonians
-  * Implemented helper functions for geometry optimization, harmonic analysis,
-    and normal-mode localization.
+* Several new features are available in the :mod:`qml.qchem <pennylane.qchem>` module to help with 
+  the construction of vibrational Hamiltonians. This includes:
+
+  * The :class:`~.qchem.VibrationalPES` class to store potential energy surface information. 
+    [(#6652)](https://github.com/PennyLaneAI/pennylane/pull/6652)
+
+    ```python
+    pes_onemode = np.array([[0.309, 0.115, 0.038, 0.008, 0.000, 0.006, 0.020, 0.041, 0.070]])
+    pes_twomode = np.zeros((1, 1, 9, 9))
+    dipole_onemode = np.zeros((1, 9, 3))
+    gauss_weights = np.array([3.96e-05, 4.94e-03, 8.85e-02,
+                                    4.33e-01, 7.20e-01, 4.33e-01,
+                                    8.85e-02, 4.94e-03, 3.96e-05])
+    grid = np.array([-3.19, -2.27, -1.47, -0.72,  0.0,  0.72,  1.47,  2.27,  3.19])
+    pes_object = qml.qchem.VibrationalPES(
+            freqs=np.array([0.025]),
+            grid=grid,
+            uloc=np.array([[1.0]]),
+            gauss_weights=gauss_weights,
+            pes_data=[pes_onemode, pes_twomode],
+            dipole_data=[dipole_onemode],
+            localized=False,
+            dipole_level=1,
+        )
+    ```
+
+  * The :func:`~.qchem.taylor_hamiltonian` function to build a Taylor Hamiltonian from a
+    :class:`~.qchem.VibrationalPES` object.
+    [(#6523)](https://github.com/PennyLaneAI/pennylane/pull/6523)
+
+    ```pycon
+    >>> qml.qchem.taylor_hamiltonian(pes_object, 4, 2)
+    (
+        0.016867926879358452 * I(0)
+      + -0.007078617919572303 * Z(0)
+      + 0.0008679410939323631 * X(0)
+    )
+    ```
+
+  * The :func:`~.qchem.taylor_bosonic` function to build a Taylor Hamiltonian in terms of Bosonic
+    operators.
+    [(#6523)](https://github.com/PennyLaneAI/pennylane/pull/6523)
+
+    ```pycon
+    >>> coeffs_arr = qml.qchem.taylor_coeffs(pes_object)
+    >>> bose_op = qml.qchem.taylor_bosonic(coeffs_arr, pes_object.freqs, is_local=pes_object.localized, uloc=pes_object.uloc)
+    >>> type(bose_op)
+    pennylane.bose.bosonic.BoseSentence
+    ```
+
+  Additional functionality is also available to optimize molecular geometries and convert between
+  representations:
+
+  * Convert Christiansen Hamiltonian integrals in the harmonic oscillator basis to integrals in the 
+    vibrational self-consistent field (VSCF) basis with the :func:`~.qchem.vscf_integrals` function. 
+    [(#6688)](https://github.com/PennyLaneAI/pennylane/pull/6688)
+
+    ```pycon
+    >>> h1 = np.array([[[0.00968289, 0.00233724, 0.0007408,  0.00199125],
+                        [0.00233724, 0.02958449, 0.00675431, 0.0021936],
+                        [0.0007408,  0.00675431, 0.0506012,  0.01280986],
+                        [0.00199125, 0.0021936,  0.01280986, 0.07282307]]])
+    >>> qml.qchem.vscf_integrals(h_integrals=[h1], modals=[4,4,4])
+    (
+      [array([[[ 9.36124041e-03,  3.63798208e-19, -3.42019607e-19,
+        -3.83743044e-19],
+        [ 9.59982270e-19,  2.77803512e-02,  5.18290259e-18,
+        -4.82000376e-18],
+        [-2.73826508e-19,  4.88583546e-18,  4.63297357e-02,
+        -2.87022759e-18],
+        [-1.94549340e-19, -5.48544743e-18, -1.41379640e-18,
+          7.92203227e-02]]])], None
+    )
+    ```
+
+  * Find the lowest energy configuration of molecules with :func:`~.qchem.optimize_geometry`.
     [(#6453)](https://github.com/PennyLaneAI/pennylane/pull/6453)
     [(#6666)](https://github.com/PennyLaneAI/pennylane/pull/6666)
-  * Implemented helper functions for calculating one-mode PES, two-mode PES, and
-    three-mode PES.
+
+    ```pycon
+    >>> symbols  = ['H', 'F']
+    >>> geometry = np.array([[0.0, 0.0, 0.0], [0.0, 0.0,  1.0]])
+    >>> mol = qml.qchem.Molecule(symbols, geometry)
+    >>> eq_geom = qml.qchem.optimize_geometry(mol)
+    >>> eq_geom
+    array([[ 0.        ,  0.        , -0.40277116],
+           [ 0.        ,  0.        ,  1.40277116]])
+    ```
+
+  * Separate normal mode frequencies and localize them with :func:`~.qchem.localize_normal_modes`.
+    [(#6453)](https://github.com/PennyLaneAI/pennylane/pull/6453)
+
+    ```pycon
+    >>> freqs = np.array([1326.66001461, 2297.26736859, 2299.65032901])
+    >>> vectors = np.array([[[ 5.71518696e-18, -4.55642350e-01,  5.20920552e-01],
+                            [ 1.13167924e-17,  4.55642350e-01,  5.20920552e-01],
+                            [-1.23163569e-17,  5.09494945e-12, -3.27565762e-02]],
+                            [[-4.53008817e-17,  4.90364125e-01,  4.90363894e-01],
+                            [-1.98591028e-16,  4.90361513e-01, -4.90361744e-01],
+                            [-2.78235498e-18, -3.08350419e-02, -6.75886679e-08]],
+                            [[ 5.75393451e-17,  5.37047963e-01,  4.41957355e-01],
+                            [ 6.53049347e-17, -5.37050348e-01,  4.41959740e-01],
+                            [-5.49709883e-17,  7.49851221e-08, -2.77912798e-02]]])
+    >>> freqs_loc, vecs_loc, uloc = qml.qchem.localize_normal_modes(freqs, vectors)
+    >>> freqs_loc
+    array([1332.62008773, 2296.73455892, 2296.7346082 ])
+    ```
+
+<h3>Labs: a place for unified and rapid prototyping of research software 🧑‍🔬</h3>
+
+The new :mod:`qml.labs <pennylane.labs>` module will house experimental research software 🔬. 
+Features here may be useful for state-of-the-art research, beta testing, or getting a sneak peek 
+into *potential* new features before they are added to PennyLane.
+
+.. warning:: 
+    This module is **experimental**! This means that features may not integrate well with other 
+    PennyLane staples like differentiability, JAX, or JIT compatibility. There may also be 
+    unexpected sharp bits 🔪 and errors ❌. Breaking changes and removals will happen without 
+    warning.
+
+Please use these features carefully and let us know your thoughts. Your feedback will inform
+how these features become a part of mainline PennyLane.
+
+<h4>Resource estimation</h4>
+
+* Resource estimation functionality in Labs is focused on being light-weight and flexible. 
+  The Labs :mod:`qml.labs.resource_estimation <pennylane.labs.resource_estimation>` module involves 
+  modifications to core PennyLane that reduce the memory requirements and computational time of 
+  resource estimation. These include new or modified base classes and one new function:
+  * :class:`~.labs.resource_estimation.Resources` - This class is simplified in `labs`, removing the arguments: `gate_sizes`, `depth`,
+    and `shots`. 
+    [(#6428)](https://github.com/PennyLaneAI/pennylane/pull/6428)
+
+  * :class:`~.labs.resource_estimation.ResourceOperator` - Replaces 
+    :class:`~.resource.ResourceOperation`, expanded to include decompositions. 
+    [(#6428)](https://github.com/PennyLaneAI/pennylane/pull/6428)
+
+  * :class:`~.labs.resource_estimation.CompressedResourceOp` - A new class with the minimum 
+    information to estimate resources: the operator type and the parameters needed to decompose it. 
+    [(#6428)](https://github.com/PennyLaneAI/pennylane/pull/6428)
+
+  * :class:`~.labs.resource_estimation.ResourceOperator` - versions of many existing PennyLane 
+    operations, like Pauli operators, :class:`~.labs.resource_estimation.ResourceHadamard`, and 
+    :class:`~.labs.resource_estimation.ResourceCNOT`. 
+    [(#6447)](https://github.com/PennyLaneAI/pennylane/pull/6447)
+    [(#6579)](https://github.com/PennyLaneAI/pennylane/pull/6579)
+    [(#6538)](https://github.com/PennyLaneAI/pennylane/pull/6538)
+    [(#6592)](https://github.com/PennyLaneAI/pennylane/pull/6592)
+
+  * :func:`~.labs.resource_estimation.get_resources()` - The new entry point to efficiently obtain 
+    the resources of quantum circuits.
+    [(#6500)](https://github.com/PennyLaneAI/pennylane/pull/6500)
+
+  Using new resource versions of existing operations and 
+  :func:`~.labs.resource_estimation.get_resources`, we can estimate resources quickly:
+
+  ```python
+  import pennylane.labs.resource_estimation as re
+  
+  def my_circuit():
+      for w in range(2):
+          re.ResourceHadamard(w)
+      re.ResourceCNOT([0, 1])
+      re.ResourceRX(1.23, 0)
+      re.ResourceRY(-4.56, 1)
+      re.ResourceQFT(wires=[0, 1, 2])
+      return qml.expval(re.ResourceHadamard(2))
+  ```
+  ```pycon
+  >>> res = re.get_resources(my_circuit)()
+  >>> print(res)
+  wires: 3
+  gates: 202
+  gate_types:
+  {'Hadamard': 5, 'CNOT': 10, 'T': 187}
+  ```
+
+  We can also set custom gate sets for decompositions:
+
+  ````pycon
+  >>> gate_set={"Hadamard","CNOT","RZ", "RX", "RY", "SWAP"}
+  >>> res = re.get_resources(my_circuit, gate_set=gate_set)()
+  >>> print(res)
+  wires: 3
+  gates: 24
+  gate_types:
+  {'Hadamard': 5, 'CNOT': 7, 'RX': 1, 'RY': 1, 'SWAP': 1, 'RZ': 9}
+  ````
+
+  Alternatively, it is possible to manually substitute associated resources:
+
+  ```pycon
+  >>> new_resources = re.substitute(res, "SWAP", re.Resources(2, 3, {"CNOT":3}))
+  >>> print(new_resources)
+  {'Hadamard': 5, 'CNOT': 10, 'RX': 1, 'RY': 1, 'RZ': 9}
+  ```
+
+<h4>Experimental functionality for handling dynamical Lie algebras (DLAs)</h4>
+
+* Use the :mod:`qml.labs.dla <pennylane.labs.dla>` module to perform the
+  [KAK decomposition](https://pennylane.ai/qml/demos/tutorial_kak_decomposition):
+  * :func:`~.labs.dla.cartan_decomp`: obtain a **Cartan decomposition** of an input **Lie algebra** 
+    via an **involution**.
+    [(#6392)](https://github.com/PennyLaneAI/pennylane/pull/6392)
+
+  * We provide a variety of **involutions** like :func:`~.labs.dla.concurrence_involution`, 
+    :func:`~.labs.dla.even_odd_involution` and canonical Cartan involutions.
+    [(#6392)](https://github.com/PennyLaneAI/pennylane/pull/6392)
+    [(#6396)](https://github.com/PennyLaneAI/pennylane/pull/6396)
+
+  * :func:`~.labs.dla.cartan_subalgebra`: compute a horizontal **Cartan subalgebra**.
+    [(#6403)](https://github.com/PennyLaneAI/pennylane/pull/6403)
+
+  * :func:`~.labs.dla.variational_kak_adj` : compute a 
+    [variational KAK decomposition](https://pennylane.ai/qml/demos/tutorial_fixed_depth_hamiltonian_simulation_via_cartan_decomposition) 
+    of a Hermitian operator using a **Cartan decomposition** and the adjoint representation of a 
+    horizontal **Cartan subalgebra**.
+    [(#6446)](https://github.com/PennyLaneAI/pennylane/pull/6446)
+
+  To use this functionality we start with a set of Hermitian operators.
+
+  ```pycon
+  >>> n = 3
+  >>> gens = [qml.X(i) @ qml.X(i + 1) for i in range(n - 1)]
+  >>> gens += [qml.Z(i) for i in range(n)]
+  >>> H = qml.sum(*gens)
+  ```
+
+  We then generate its Lie algebra by computing the Lie closure.
+
+  ```pycon
+  >>> g = qml.lie_closure(gens)
+  >>> g = [op.pauli_rep for op in g]
+  >>> print(g)
+  [1 * X(0) @ X(1), 1 * X(1) @ X(2), 1.0 * Z(0), ...]
+  ```
+
+  We then choose an involution (e.g. :func:`~.labs.dla.concurrence_involution`) that defines a 
+  Cartan decomposition `g = k + m`. `k` is the vertical subalgebra, and `m` its horizontal 
+  complement (not a subalgebra).
+
+  ```pycon
+  >>> from pennylane.labs.dla import concurrence_involution, cartan_decomp
+  >>> involution = concurrence_involution
+  >>> k, m = cartan_decomp(g, involution=involution)
+  ```
+
+  The next step is just re-ordering the basis elements in `g` and computing its 
+  `structure_constants`.
+
+  ```pycon
+  >>> g = k + m
+  >>> adj = qml.structure_constants(g)
+  ```
+
+  We can then compute a (horizontal) Cartan subalgebra `a`, that is, a maximal Abelian subalgebra of 
+  `m`.
+
+  ```pycon
+  >>> from pennylane.labs.dla import cartan_subalgebra
+  >>> g, k, mtilde, a, adj = cartan_subalgebra(g, k, m, adj)
+  ```
+
+  Having determined both subalgebras `k` and `a`, we can compute the KAK decomposition variationally 
+  like in [2104.00728](https://arxiv.org/abs/2104.00728), see our 
+  [demo on KAK decomposition in practice](https://pennylane.ai/qml/demos/tutorial_fixed_depth_hamiltonian_simulation_via_cartan_decomposition).
+
+  ```pycon
+  >>> from pennylane.labs.dla import variational_kak_adj
+  >>> dims = (len(k), len(mtilde), len(a))
+  >>> adjvec_a, theta_opt = variational_kak_adj(H, g, dims, adj, opt_kwargs={"n_epochs": 3000})
+  ```
+
+* We also provide some additional features that are useful for handling dynamical Lie algebras.
+  * :func:`~.labs.dla.recursive_cartan_decomp`: perform consecutive recursive Cartan decompositions.
+    [(#6396)](https://github.com/PennyLaneAI/pennylane/pull/6396)
+
+  * :func:`~.labs.dla.lie_closure_dense`: extension of `qml.lie_closure` using dense matrices.
+    [(#6371)](https://github.com/PennyLaneAI/pennylane/pull/6371)
+    [(#6695)](https://github.com/PennyLaneAI/pennylane/pull/6695)
+
+  * :func:`~.labs.dla.structure_constants_dense`: extension of `qml.structure_constants` using dense 
+    matrices.
+    [(#6396)](https://github.com/PennyLaneAI/pennylane/pull/6396) [(#6376)](https://github.com/PennyLaneAI/pennylane/pull/6376)
+
+
+<h4>Vibrational Hamiltonians</h4>
+
+* New functionality in labs helps with the construction of vibrational Hamiltonians.
+  * Generate potential energy surfaces (PES) with `qml.labs.vibrational.vibrational_pes`.
     [(#6616)](https://github.com/PennyLaneAI/pennylane/pull/6616)
     [(#6676)](https://github.com/PennyLaneAI/pennylane/pull/6676)
-  * Implemented wrapper function for vibrational Hamiltonian calculation and dataclass
-    for storing the data.
-    [(#6652)](https://github.com/PennyLaneAI/pennylane/pull/6652)
-  * Implemented functions for generating the vibrational Hamiltonian in VSCF basis
-    [(#6688)](https://github.com/PennyLaneAI/pennylane/pull/6688)
-
-* Added support to build a vibrational Hamiltonian in Taylor form.
-  [(#6523)](https://github.com/PennyLaneAI/pennylane/pull/6523)
+  
+    ```pycon
+    >>> symbols  = ['H', 'F']
+    >>> geometry = np.array([[0.0, 0.0, 0.0], [0.0, 0.0, 1.0]])
+    >>> mol = qml.qchem.Molecule(symbols, geometry)
+    >>> pes = vibrational_pes(mol)
+    ```
+  * Use the `qml.labs.vibrational.christiansen_hamiltonian` function and potential energy surfaces 
+    to generate Hamiltonians in the Ch  ristiansen form.
+    [(#6560)](https://github.com/PennyLaneAI/pennylane/pull/6560)
 
 <h3>Improvements 🛠</h3>
 
@@ -120,99 +608,122 @@
   [(#6573)](https://github.com/PennyLaneAI/pennylane/pull/6573)
   [(#6611)](https://github.com/PennyLaneAI/pennylane/pull/6611)
 
-* Added `qml.qchem.symmetry_shift` function to perform the
-  [block-invariant symmetry shift](https://arxiv.org/pdf/2304.13772) on the electronic integrals.
+* A new function for performing the [block-invariant symmetry shift](https://arxiv.org/pdf/2304.13772) 
+  on electronic integrals has been added with `qml.qchem.symmetry_shift`.
   [(#6574)](https://github.com/PennyLaneAI/pennylane/pull/6574)
 
-* Added JAX support for the differentiable Hartree-Fock workflow.
+* The differentiable Hartree-Fock workflow is now compatible with JAX.
   [(#6096)](https://github.com/PennyLaneAI/pennylane/pull/6096)
   [(#6707)](https://github.com/PennyLaneAI/pennylane/pull/6707)
 
 <h4>Transform for combining GlobalPhase instances</h4>
 
-* Added a new `qml.transforms.combine_global_phases` transform to combine all `qml.GlobalPhase` gates in a circuit into a single one applied at the end.
-  This can be useful for circuits that include a lot of `qml.GlobalPhase` gates, which can be introduced directly during circuit creation,
-  decompositions that include `qml.GlobalPhase` gates, etc.
+* A new transform called `qml.transforms.combine_global_phases` has been added. It combines all 
+  `qml.GlobalPhase` gates in a circuit into a single one applied at the end. This can be useful for 
+  circuits that include a lot of `qml.GlobalPhase` gates that are introduced directly during 
+  circuit creation, decompositions that include `qml.GlobalPhase` gates, etc.
   [(#6686)](https://github.com/PennyLaneAI/pennylane/pull/6686)
 
 <h4>Better drawing functionality</h4>
 
-* Added support for the `wire_options` dictionary to customize wire line formatting in `qml.draw_mpl` circuit
-  visualizations, allowing global and per-wire customization with options like `color`, `linestyle`, and `linewidth`.
+* `qml.draw_mpl` now has a `wire_options` keyword argument, which allows for global- and per-wire 
+  customization with options like `color`, `linestyle`, and `linewidth`.
   [(#6486)](https://github.com/PennyLaneAI/pennylane/pull/6486)
 
+  Here is an example that would make all wires cyan and bold except for wires 2 and 6, which are 
+  dashed and a different colour.
+
+  ```python
+  @qml.qnode(qml.device("default.qubit"))
+  def circuit(x):
+      for w in range(5):
+          qml.Hadamard(w) 
+      return qml.expval(qml.PauliZ(0) @ qml.PauliY(1))
+
+  wire_options = {"color": "cyan", 
+                  "linewidth": 5, 
+                  2: {"linestyle": "--", "color": "red"}, 
+                  6: {"linestyle": "--", "color": "orange"}
+              }
+  print(qml.draw_mpl(circuit, wire_options=wire_options)(0.52))
+  ```
+
 <h4>New device capabilities 💾</h4>
 
-* Two new methods: `setup_execution_config` and `preprocess_transforms` are added to the `Device`
-  class. Device developers are encouraged to override these two methods separately instead of the
+* Two new methods, `setup_execution_config` and `preprocess_transforms`, have been added to the 
+  `Device` class. Device developers are encouraged to override these two methods separately instead of the
   `preprocess` method. For now, to avoid ambiguity, a device is allowed to override either these
   two methods or `preprocess`, but not both. In the long term, we will slowly phase out the use of
   `preprocess` in favour of these two methods for better separation of concerns.
   [(#6617)](https://github.com/PennyLaneAI/pennylane/pull/6617)
 
 * Developers of plugin devices now have the option of providing a TOML-formatted configuration file
-  to declare the capabilities of the device. See [Device Capabilities](https://docs.pennylane.ai/en/latest/development/plugins.html#device-capabilities) for details.
+  to declare the capabilities of the device. See
+  [Device Capabilities](https://docs.pennylane.ai/en/latest/development/plugins.html#device-capabilities) 
+  for details.
 
-* An internal module `pennylane.devices.capabilities` is added that defines a new `DeviceCapabilites`
-  data class, as well as functions that load and parse the TOML-formatted configuration files.
+* An internal module called `qml.devices.capabilities` has been added that defines a new 
+  `DeviceCapabilites` data class, as well as functions that load and parse the TOML-formatted 
+  configuration files.
   [(#6407)](https://github.com/PennyLaneAI/pennylane/pull/6407)
 
   ```pycon
-    >>> from pennylane.devices.capabilities import DeviceCapabilities
-    >>> capabilities = DeviceCapabilities.from_toml_file("my_device.toml")
-    >>> isinstance(capabilities, DeviceCapabilities)
-    True
+  >>> from pennylane.devices.capabilities import DeviceCapabilities
+  >>> capabilities = DeviceCapabilities.from_toml_file("my_device.toml")
+  >>> isinstance(capabilities, DeviceCapabilities)
+  True
   ```
 
-* Devices that extends `qml.devices.Device` now has an optional class attribute `capabilities`
-  that is an instance of the `DeviceCapabilities` data class, constructed from the configuration
-  file if it exists. Otherwise, it is set to `None`.
+* Devices that extend `qml.devices.Device` now have an optional class attribute called 
+  `capabilities`, which is an instance of the `DeviceCapabilities` data class constructed from the 
+  configuration file if it exists. Otherwise, it is set to `None`.
   [(#6433)](https://github.com/PennyLaneAI/pennylane/pull/6433)
 
   ```python
   from pennylane.devices import Device
 
   class MyDevice(Device):
-
       config_filepath = "path/to/config.toml"
-
       ...
   ```
+
   ```pycon
   >>> isinstance(MyDevice.capabilities, DeviceCapabilities)
   True
   ```
 
 * Default implementations of `Device.setup_execution_config` and `Device.preprocess_transforms`
-  are added to the device API for devices that provides a TOML configuration file and thus have
-  a `capabilities` property.
+  have been added to the device API for devices that provide a TOML configuration file and, thus, 
+  have a `capabilities` property.
   [(#6632)](https://github.com/PennyLaneAI/pennylane/pull/6632)
   [(#6653)](https://github.com/PennyLaneAI/pennylane/pull/6653)
 
 <h4>Capturing and representing hybrid programs</h4>
 
-* Support is added for `if`/`else` statements and `for` and `while` loops in circuits executed with `qml.capture.enabled`, via Autograph.
-  Autograph conversion is now used by default in `make_plxpr`, but can be skipped with the keyword arg `autograph=False`.
+* Support has been added for `if`/`else` statements and `for` and `while` loops in circuits executed 
+  with `qml.capture.enabled`, via Autograph. Autograph conversion is now used by default in 
+  `make_plxpr`, but can be skipped with `autograph=False`.
   [(#6406)](https://github.com/PennyLaneAI/pennylane/pull/6406)
   [(#6413)](https://github.com/PennyLaneAI/pennylane/pull/6413)
   [(#6426)](https://github.com/PennyLaneAI/pennylane/pull/6426)
   [(#6645)](https://github.com/PennyLaneAI/pennylane/pull/6645)
   [(#6685)](https://github.com/PennyLaneAI/pennylane/pull/6685)
 
-* `qml.transform` now accepts a `plxpr_transform` argument. This argument must be a function that can transform plxpr.
-  Note that executing a transformed function will currently raise a `NotImplementedError`. To see more details, check
-  out the documentation of `qml.transform`.
+* `qml.transform` now accepts a `plxpr_transform` argument. This argument must be a function that 
+  can transform plxpr. Note that executing a transformed function will currently raise a 
+  `NotImplementedError`. To see more details, check out the 
+  :func:`documentation of qml.transform <pennylane.transform>`.
   [(#6633)](https://github.com/PennyLaneAI/pennylane/pull/6633)
   [(#6722)](https://github.com/PennyLaneAI/pennylane/pull/6722)
 
-* Users can now apply transforms with program capture enabled. Transformed functions cannot be executed by default. To apply
-  the transforms (and be able to execute the function), it must be decorated with the new `qml.capture.expand_plxpr_transforms`
-  function, which accepts a callable as input and returns a new function to which all present transforms have been applied.
+* Users can now apply transforms with program capture enabled. Transformed functions cannot be
+  executed by default. To apply the transforms (and to be able to execute the function), it must be 
+  decorated with the new `qml.capture.expand_plxpr_transforms` function, which accepts a callable as 
+  input and returns a new function for which all present transforms have been applied.
   [(#6722)](https://github.com/PennyLaneAI/pennylane/pull/6722)
 
   ```python
   from functools import partial
-  import jax
 
   qml.capture.enable()
   wire_map = {0: 3, 1: 6, 2: 9}
@@ -252,29 +763,31 @@
     in (d,) }
   ```
 
-* The `qml.iterative_qpe` function can now be compactly captured into jaxpr.
+* The `qml.iterative_qpe` function can now be compactly captured into plxpr.
   [(#6680)](https://github.com/PennyLaneAI/pennylane/pull/6680)
 
-* Functions and plxpr can now be natively transformed using the new `qml.capture.transforms.CancelInterpreter`
-  when program capture is enabled. This class cancels operators appearing consecutively that are adjoints of each
-  other, and follows the same API as `qml.transforms.cancel_inverses`.
-  [(#6692)](https://github.com/PennyLaneAI/pennylane/pull/6692)
+* Three new plxpr interpreters have been added that allow for functions and plxpr to be natively 
+  transformed with the same API as the corresponding existing transforms in PennyLane when program
+  capture is enabled:
+
+  * `qml.capture.transforms.CancelInterpreter`:this class cancels operators appearing consecutively 
+    that are adjoints of each other following the same API as `qml.transforms.cancel_inverses`.
+    [(#6692)](https://github.com/PennyLaneAI/pennylane/pull/6692)
 
-* Functions and plxpr can now be natively transformed using the new `qml.capture.transforms.DecomposeInterpreter`
-  when program capture is enabled. This class decomposes pennylane operators following the same API as
-  `qml.transforms.decompose`.
-  [(#6691)](https://github.com/PennyLaneAI/pennylane/pull/6691)
+  * `qml.capture.transforms.DecomposeInterpreter`: this class decomposes pennylane operators 
+    following the same API as `qml.transforms.decompose`.
+    [(#6691)](https://github.com/PennyLaneAI/pennylane/pull/6691)
 
-* Implemented a `MapWiresInterpreter` class that can be used as a quantum transform to map
-  operator and measurement wires with capture enabled.
-  [(#6697)](https://github.com/PennyLaneAI/pennylane/pull/6697)
+  * `qml.capture.transforms.MapWiresInterpreter`: this class maps wires to new values following the 
+    same API as `qml.map_wires`.
+    [(#6697)](https://github.com/PennyLaneAI/pennylane/pull/6697)
 
-* A `qml.tape.plxpr_to_tape` function can now convert plxpr to a tape.
+* A `qml.tape.plxpr_to_tape` function is now available that converts plxpr to a tape.
   [(#6343)](https://github.com/PennyLaneAI/pennylane/pull/6343)
 
 * Execution with capture enabled now follows a new execution pipeline and natively passes the
-  captured jaxpr to the device. Since it no longer falls back to the old pipeline, execution
-  only works with a reduced feature set.
+  captured plxpr to the device. Since it no longer falls back to the old pipeline, execution only 
+  works with a reduced feature set.
   [(#6655)](https://github.com/PennyLaneAI/pennylane/pull/6655)
   [(#6596)](https://github.com/PennyLaneAI/pennylane/pull/6596)
 
@@ -286,16 +799,17 @@
   [(#6422)](https://github.com/PennyLaneAI/pennylane/pull/6422)
   [(#6668)](https://github.com/PennyLaneAI/pennylane/pull/6668)
 
-* `qml.capture.PlxprInterpreter` base class has been added for easy transformation and execution of
-  pennylane variant jaxpr.
+* A `qml.capture.PlxprInterpreter` base class has been added for easy transformation and execution 
+  of plxpr.
   [(#6141)](https://github.com/PennyLaneAI/pennylane/pull/6141)
 
-* A `DefaultQubitInterpreter` class has been added to provide plxpr execution using python based tools,
-  and the `DefaultQubit.eval_jaxpr` method is now implemented.
+* A `DefaultQubitInterpreter` class has been added to provide plxpr execution using python based 
+  tools, and the `DefaultQubit.eval_jaxpr` method has been implemented.
   [(#6594)](https://github.com/PennyLaneAI/pennylane/pull/6594)
   [(#6328)](https://github.com/PennyLaneAI/pennylane/pull/6328)
 
-* An optional method `eval_jaxpr` is added to the device API for native execution of plxpr programs.
+* An optional method, `eval_jaxpr`, has been added to the device API for native execution of plxpr 
+  programs.
   [(#6580)](https://github.com/PennyLaneAI/pennylane/pull/6580)
 
 * `qml.capture.qnode_call` has been made private and moved to the `workflow` module.
@@ -303,41 +817,45 @@
 
 <h4>Other Improvements</h4>
 
-* `qml.math.grad` and `qml.math.jacobian` added to differentiate a function with inputs of any
-  interface in a jax-like manner.
+* `qml.math.grad` and `qml.math.jacobian` have been added to differentiate a function with inputs of 
+  any interface in a JAX-like manner.
   [(#6741)](https://github.com/PennyLaneAI/pennylane/pull/6741)
 
 * `qml.GroverOperator` now has a `work_wires` property.
   [(#6738)](https://github.com/PennyLaneAI/pennylane/pull/6738)
 
-* `Wires` object usage across Pennylane source code has been tidied up.
+* The `Wires` object's usage across Pennylane source code has been tidied up for internal 
+  consistency.
   [(#6689)](https://github.com/PennyLaneAI/pennylane/pull/6689)
 
-* `qml.equal` now supports `PauliWord` and `PauliSentence` instances.
+* `qml.equal` now supports `qml.PauliWord` and `qml.PauliSentence` instances.
   [(#6703)](https://github.com/PennyLaneAI/pennylane/pull/6703)
 
-* Remove redundant commutator computations from `qml.lie_closure`.
+* Redundant commutator computations from `qml.lie_closure` have been removed.
   [(#6724)](https://github.com/PennyLaneAI/pennylane/pull/6724)
 
-* Raises a comprehensive error when using `qml.fourier.qnode_spectrum` with standard numpy
+* A comprehensive error is now raised when using `qml.fourier.qnode_spectrum` with standard Numpy
   arguments and `interface="auto"`.
   [(#6622)](https://github.com/PennyLaneAI/pennylane/pull/6622)
 
-* Added Pauli String representations for the gates X, Y, Z, S, T, SX, SWAP, ISWAP, ECR, SISWAP. Fixed a shape error in the matrix conversion of `PauliSentence`s with list or array input.
+* Pauli string representations for the gates `{X, Y, Z, S, T, SX, SWAP, ISWAP, ECR, SISWAP}` have 
+  been added, and a shape error in the matrix conversion of `qml.PauliSentence`s with `list` or 
+  `array` inputs has been fixed.
   [(#6562)](https://github.com/PennyLaneAI/pennylane/pull/6562)
   [(#6587)](https://github.com/PennyLaneAI/pennylane/pull/6587)
   
-* `QNode` and `qml.execute` now forbid certain keyword arguments from being passed positionally.
+* `qml.QNode` and `qml.execute` now forbid certain keyword arguments from being passed positionally.
   [(#6610)](https://github.com/PennyLaneAI/pennylane/pull/6610)
 
-* Shortened the string representation for the `qml.S`, `qml.T`, and `qml.SX` operators.
+* The string representations for the `qml.S`, `qml.T`, and `qml.SX` have been shortened.
   [(#6542)](https://github.com/PennyLaneAI/pennylane/pull/6542)
 
-* Added functions and dunder methods to add and multiply Resources objects in series and in parallel.
+* Internal class functions and dunder methods have been added to allow for multiplying Resources 
+  objects in series and in parallel.
   [(#6567)](https://github.com/PennyLaneAI/pennylane/pull/6567)
 
 * The `diagonalize_measurements` transform no longer raises an error for unknown observables. Instead,
-  they are left undiagonalized, with the expectation that observable validation will catch any undiagonalized
+  they are left un-diagonalized, with the expectation that observable validation will catch any un-diagonalized
   observables that are also unsupported by the device.
   [(#6653)](https://github.com/PennyLaneAI/pennylane/pull/6653)
 
@@ -349,26 +867,26 @@
   [(#6630)](https://github.com/PennyLaneAI/pennylane/pull/6630)
   [(#6736)](https://github.com/PennyLaneAI/pennylane/pull/6736)
 
-* Add developer focused `run` function to `qml.workflow` module.
+* A developer focused `run` function has been added to the `qml.workflow` module for a cleaner and 
+  standardized approach to executing tapes on an ML interface.
   [(#6657)](https://github.com/PennyLaneAI/pennylane/pull/6657)
 
-* Standardize supported interfaces to an internal `Enum` object. 
+* Internal changes have been made to standardize execution interfaces, which resolves ambiguities in 
+  how the `interface` value is handled during execution.
   [(#6643)](https://github.com/PennyLaneAI/pennylane/pull/6643)
 
-* Moved all interface handling logic to `interface_utils.py` in the `qml.math` module.
+* All interface handling logic has been moved to `interface_utils.py` in the `qml.math` module.
   [(#6649)](https://github.com/PennyLaneAI/pennylane/pull/6649)
 
 * `qml.execute` can now be used with `diff_method="best"`.
   Classical cotransform information is now handled lazily by the workflow. Gradient method
-  validation and program setup is now handled inside of `qml.execute`, instead of in `QNode`.
+  validation and program setup are now handled inside of `qml.execute`, instead of in `QNode`.
   [(#6716)](https://github.com/PennyLaneAI/pennylane/pull/6716)
 
-* Added PyTree support for measurements in a circuit. 
+* PyTree support for measurements in a circuit has been added.
   [(#6378)](https://github.com/PennyLaneAI/pennylane/pull/6378)
 
   ```python
-  import pennylane as qml
-
   @qml.qnode(qml.device("default.qubit"))
   def circuit():
       qml.Hadamard(0)
@@ -380,182 +898,139 @@
   {'Probabilities': array([0.5, 0. , 0. , 0.5]), 'State': array([0.70710678+0.j, 0.        +0.j, 0.        +0.j, 0.70710678+0.j])}
   ```
 
-* `_cache_transform` transform has been moved to its own file located
-  at `qml.workflow._cache_transform.py`.
+* The `_cache_transform` transform has been moved to its own file located in 
+  `pennylane/workflow/_cache_transform.py`.
   [(#6624)](https://github.com/PennyLaneAI/pennylane/pull/6624)
 
-* `qml.BasisRotation` template is now JIT compatible.
+* The `qml.BasisRotation` template is now JIT compatible.
   [(#6019)](https://github.com/PennyLaneAI/pennylane/pull/6019)
   [(#6779)](https://github.com/PennyLaneAI/pennylane/pull/6779)
 
 * The Jaxpr primitives for `for_loop`, `while_loop` and `cond` now store slices instead of
-  numbers of args.
+  numbers of arguments. This helps with keeping track of what order the arguments come in.
   [(#6521)](https://github.com/PennyLaneAI/pennylane/pull/6521)
 
-* Expand `ExecutionConfig.gradient_method` to store `TransformDispatcher` type.
+* The `ExecutionConfig.gradient_method` function has been expanded to store `TransformDispatcher` 
+  type.
   [(#6455)](https://github.com/PennyLaneAI/pennylane/pull/6455)
 
-* Fix the string representation of `Resources` instances to match the attribute names.
+* The string representation of `Resources` instances has been improved to match the attribute names.
   [(#6581)](https://github.com/PennyLaneAI/pennylane/pull/6581)
 
-* Improved documentation for the `dynamic_one_shot` transform, and a warning is raised when a user-applied `dynamic_one_shot` transform is ignored in favour of the existing transform in a device's preprocessing transform program.
+* The documentation for the `dynamic_one_shot` transform has been improved, and a warning is raised 
+  when a user-applied `dynamic_one_shot` transform is ignored in favour of the existing transform in 
+  a device's preprocessing transform program.
   [(#6701)](https://github.com/PennyLaneAI/pennylane/pull/6701)
 
-* Added `qml.devices.qubit_mixed` module for mixed-state qubit device support [(#6379)](https://github.com/PennyLaneAI/pennylane/pull/6379). This module introduces an `apply_operation` helper function that features:
-
+* A `qml.devices.qubit_mixed` module has been added for mixed-state qubit device support. This 
+  module introduces an `apply_operation` helper function that features:
   * Two density matrix contraction methods using `einsum` and `tensordot`
-  * Optimized handling of special cases including: Diagonal operators, Identity operators, CX (controlled-X), Multi-controlled X gates, Grover operators
+  * Optimized handling of special cases including: Diagonal operators, Identity operators, CX 
+    (controlled-X), Multi-controlled X gates, Grover operators
+  [(#6379)](https://github.com/PennyLaneAI/pennylane/pull/6379)
 
-* Added submodule 'initialize_state' featuring a `create_initial_state` function for initializing a density matrix from `qml.StatePrep` operations or `qml.QubitDensityMatrix` operations.
+* A function called `create_initial_state` has been added to allow for initializing a circuit with a 
+  density matrix using `qml.StatePrep` or `qml.QubitDensityMatrix`.
   [(#6503)](https://github.com/PennyLaneAI/pennylane/pull/6503)
-  
-* Added method `preprocess` to the `QubitMixed` device class to preprocess the quantum circuit before execution. Necessary non-intrusive interfaces changes to class init method were made along the way to the `QubitMixed` device class to support new API feature.
-  [(#6601)](https://github.com/PennyLaneAI/pennylane/pull/6601)
-
-* Added a second class `DefaultMixedNewAPI` to the `qml.devices.qubit_mixed` module, which is to be the replacement of legacy `DefaultMixed` which for now to hold the implementations of `preprocess` and `execute` methods.
-  [(#6607)](https://github.com/PennyLaneAI/pennylane/pull/6607)
-
-* Added submodule `devices.qubit_mixed.measure` as a necessary step for the new API, featuring a `measure` function for measuring qubits in mixed-state devices.
-  [(#6637)](https://github.com/PennyLaneAI/pennylane/pull/6637)
-
-* Added submodule `devices.qubit_mixed.simulate` as a necessary step for the new API,
-featuring a `simulate` function for simulating mixed states in analytic mode.
-  [(#6618)](https://github.com/PennyLaneAI/pennylane/pull/6618)
-
-* Added submodule `devices.qubit_mixed.sampling` as a necessary step for the new API, featuring functions `sample_state`, `measure_with_samples` and `sample_probs` for sampling qubits in mixed-state devices.
-  [(#6639)](https://github.com/PennyLaneAI/pennylane/pull/6639)
-
-* Implemented the finite-shot branch of `devices.qubit_mixed.simulate`. Now, the 
-new device API of `default_mixed` should be able to take the stochastic arguments
-such as `shots`, `rng` and `prng_key`.
-[(#6665)](https://github.com/PennyLaneAI/pennylane/pull/6665)
-
-* Added support `qml.Snapshot` operation in `qml.devices.qubit_mixed.apply_operation`.
-  [(#6659)](https://github.com/PennyLaneAI/pennylane/pull/6659)
-
-<h3>Labs: a place for unified and rapid prototyping of research software 🧪</h3>
-
-<h4>Resource estimation</h4>
-
-* Added base class `Resources`, `CompressedResourceOp`, `ResourceOperator` for advanced resource estimation.
-  [(#6428)](https://github.com/PennyLaneAI/pennylane/pull/6428)
-
-* Added `get_resources()` functionality which allows users to extract resources from a quantum function, tape or
-  resource operation. Additionally added some standard gatesets `DefaultGateSet` to track resources with respect to.
-  [(#6500)](https://github.com/PennyLaneAI/pennylane/pull/6500)
-
-* Added `ResourceOperator` classes for QFT and all operators in QFT's decomposition.
-  [(#6447)](https://github.com/PennyLaneAI/pennylane/pull/6447)
-
-* Added native `ResourceOperator` subclasses for each of the controlled operators.
-  [(#6579)](https://github.com/PennyLaneAI/pennylane/pull/6579)
-
-* Added native `ResourceOperator` subclasses for each of the multi qubit operators.
-  [(#6538)](https://github.com/PennyLaneAI/pennylane/pull/6538)
-
-* Added abstract `ResourceOperator` subclasses for Adjoint, Controlled, and Pow
-  symbolic operation classes.
-  [(#6592)](https://github.com/PennyLaneAI/pennylane/pull/6592)
-
-<h4>Experimental functionality for handling dynamical Lie algebras (DLAs)</h4>
-
-* Added a dense implementation of computing the Lie closure in a new function
-  `lie_closure_dense` in `pennylane.labs.dla`.
-  [(#6371)](https://github.com/PennyLaneAI/pennylane/pull/6371)
-  [(#6695)](https://github.com/PennyLaneAI/pennylane/pull/6695)
-
-* Added a dense implementation of computing the structure constants in a new function
-  `structure_constants_dense` in `pennylane.labs.dla`.
-  [(#6376)](https://github.com/PennyLaneAI/pennylane/pull/6376)
-
-* Added utility functions for handling dense matrices and advanced functionality in the Lie theory context.
-  [(#6563)](https://github.com/PennyLaneAI/pennylane/pull/6563)
-  [(#6392)](https://github.com/PennyLaneAI/pennylane/pull/6392)
-  [(#6396)](https://github.com/PennyLaneAI/pennylane/pull/6396)
-
-* Added a ``cartan_decomp`` function along with two standard involutions ``even_odd_involution`` and ``concurrence_involution``.
-  [(#6392)](https://github.com/PennyLaneAI/pennylane/pull/6392)
-
-* Added a `recursive_cartan_decomp` function and all canonical Cartan involutions.
-  [(#6396)](https://github.com/PennyLaneAI/pennylane/pull/6396)
 
-* Added a `cartan_subalgebra` function to compute the (horizontal) Cartan subalgebra of a Cartan decomposition.
-  [(#6403)](https://github.com/PennyLaneAI/pennylane/pull/6403)
-  [(#6396)](https://github.com/PennyLaneAI/pennylane/pull/6396)
-
-* Added a `variational_kak_adj` function to compute a KaK decomposition of a Hamiltonian given a Cartan
-  decomposition and the ordered adjoint representation of the Lie algebra.
-  [(#6446)](https://github.com/PennyLaneAI/pennylane/pull/6446)
-
-* Improved documentation by fixing broken links and latex issues. Also consistently use `$\mathfrak{a}$`
-  for the horizontal Cartan subalgebra instead of `$\mathfrak{h}$`.
-  [(#6747)](https://github.com/PennyLaneAI/pennylane/pull/6747)
+* Several additions have been made to eventually migrate the `"default.mixed"` device to the new 
+  device API:
+  * A `preprocess` method has been added to the `QubitMixed` device class to preprocess the quantum 
+    circuit before execution.
+    [(#6601)](https://github.com/PennyLaneAI/pennylane/pull/6601)
+  * A new class called `DefaultMixedNewAPI` has been added to the `qml.devices.qubit_mixed` module, 
+    which will replace the legacy `DefaultMixed`. 
+    [(#6607)](https://github.com/PennyLaneAI/pennylane/pull/6607)
+  * A new submodule called `devices.qubit_mixed.measure` has been added, featuring a `measure` 
+    function for measuring qubits in mixed-state devices.
+    [(#6637)](https://github.com/PennyLaneAI/pennylane/pull/6637)
+  * A new submodule called `devices.qubit_mixed.simulate` has been added, featuring a `simulate` 
+    function for simulating mixed states in analytic mode.
+    [(#6618)](https://github.com/PennyLaneAI/pennylane/pull/6618)
+  * A new submodule called `devices.qubit_mixed.sampling` has been added, featuring functions 
+    `sample_state`, `measure_with_samples` and `sample_probs` for sampling qubits in mixed-state 
+    devices.
+    [(#6639)](https://github.com/PennyLaneAI/pennylane/pull/6639)
+  * The finite-shot branch of `devices.qubit_mixed.simulate` has been added, which allows for 
+    accepting stochastic arguments such as `shots`, `rng` and `prng_key`.
+    [(#6665)](https://github.com/PennyLaneAI/pennylane/pull/6665)
+  * Support for `qml.Snapshot` has been added.
+    [(#6659)](https://github.com/PennyLaneAI/pennylane/pull/6659)
+
+* Reporting of test warnings as failures has been added.
+  [(#6217)](https://github.com/PennyLaneAI/pennylane/pull/6217)
 
-<h4>Construct vibrational Hamiltonians 🫨</h4>
+* A warning message in the Gradients and training documentation has been added that pertains to 
+  `ComplexWarning`s.
+  [(#6543)](https://github.com/PennyLaneAI/pennylane/pull/6543)
 
-* Added support to build a vibrational Hamiltonian in the Christiansen form.
-  [(#6560)](https://github.com/PennyLaneAI/pennylane/pull/6560)
-  [(#6792)](https://github.com/PennyLaneAI/pennylane/pull/6792)
+* A new figure was added to the landing page of the PennyLane website.
+  [(#6696)](https://github.com/PennyLaneAI/pennylane/pull/6696)
 
 <h3>Breaking changes 💔</h3>
 
-* The default graph coloring method of `qml.dot`, `qml.sum`, and `qml.pauli.optimize_measurements` for grouping observables was changed 
-  from `"rlf"` to `"lf"`. Internally, `qml.pauli.group_observables` has been replaced with `qml.pauli.compute_partition_indices`
-  in several places to improve efficiency.
+* The default graph coloring method of `qml.dot`, `qml.sum`, and `qml.pauli.optimize_measurements` 
+  for grouping observables was changed from `"rlf"` to `"lf"`. Internally, 
+  `qml.pauli.group_observables` has been replaced with `qml.pauli.compute_partition_indices` in 
+  several places to improve efficiency.
   [(#6706)](https://github.com/PennyLaneAI/pennylane/pull/6706)
 
-* `qml.fourier.qnode_spectrum` no longer automatically converts pure numpy parameters to the
+* `qml.fourier.qnode_spectrum` no longer automatically converts pure Numpy parameters to the
   Autograd framework. As the function uses automatic differentiation for validation, parameters
-  from an autodiff framework have to be used.
+  from such a framework have to be used.
   [(#6622)](https://github.com/PennyLaneAI/pennylane/pull/6622)
 
-* `qml.math.jax_argnums_to_tape_trainable` is moved and made private to avoid a qnode dependency
-  in the math module.
+* `qml.math.jax_argnums_to_tape_trainable` has been moved and made private to avoid an unnecessary 
+  QNode dependency in the `qml.math` module.
   [(#6609)](https://github.com/PennyLaneAI/pennylane/pull/6609)
 
-* Gradient transforms are now applied after the user's transform program.
+* Gradient transforms are now applied after the user's transform program. This ensures user 
+  transforms work as expected on initial structures (e.g., embeddings or entangling layers), 
+  guarantees that gradient transforms only process compatible operations, aligns transform order 
+  with user expectations, and avoids confusion.
   [(#6590)](https://github.com/PennyLaneAI/pennylane/pull/6590)
 
-* Legacy operator arithmetic has been removed. This includes `qml.ops.Hamiltonian`, `qml.operation.Tensor`,
-  `qml.operation.enable_new_opmath`, `qml.operation.disable_new_opmath`, and `qml.operation.convert_to_legacy_H`.
-  Note that `qml.Hamiltonian` will continue to dispatch to `qml.ops.LinearCombination`. For more information,
-  check out the [updated operator troubleshooting page](https://docs.pennylane.ai/en/stable/news/new_opmath.html).
+* Legacy operator arithmetic has been removed. This includes `qml.ops.Hamiltonian`, 
+  `qml.operation.Tensor`, `qml.operation.enable_new_opmath`, `qml.operation.disable_new_opmath`, and 
+  `qml.operation.convert_to_legacy_H`. Note that `qml.Hamiltonian` will continue to dispatch to 
+  `qml.ops.LinearCombination`. For more information, check out the 
+  [updated operator troubleshooting page](https://docs.pennylane.ai/en/stable/news/new_opmath.html).
   [(#6548)](https://github.com/PennyLaneAI/pennylane/pull/6548)
   [(#6602)](https://github.com/PennyLaneAI/pennylane/pull/6602)
   [(#6589)](https://github.com/PennyLaneAI/pennylane/pull/6589)
 
-* The developer-facing `qml.utils` module has been removed. Specifically, the
-following 4 sets of functions have been either moved or removed[(#6588)](https://github.com/PennyLaneAI/pennylane/pull/6588):
-
-  * `qml.utils._flatten`, `qml.utils.unflatten` has been moved and renamed to `qml.optimize.qng._flatten_np` and `qml.optimize.qng._unflatten_np` respectively.
+* The developer-facing `qml.utils` module has been removed. 
+  [(#6588)](https://github.com/PennyLaneAI/pennylane/pull/6588):
 
-  * `qml.utils._inv_dict` and `qml._get_default_args` have been removed.
+  Specifically, the following 4 sets of functions have been either moved or removed:
+    * `qml.utils._flatten`, `qml.utils.unflatten` has been moved and renamed to `qml.optimize.qng._flatten_np` and `qml.optimize.qng._unflatten_np` respectively.
+    * `qml.utils._inv_dict` and `qml._get_default_args` have been removed.
+    * `qml.utils.pauli_eigs` has been moved to `qml.pauli.utils`.
+    * `qml.utils.expand_vector` has been moved to `qml.math.expand_vector`.
 
-  * `qml.utils.pauli_eigs` has been moved to `qml.pauli.utils`.
-
-  * `qml.utils.expand_vector` has been moved to `qml.math.expand_vector`.
-
-* The `qml.qinfo` module has been removed. Please see the respective functions in the `qml.math` and `qml.measurements`
-  modules instead.
+* The `qml.qinfo` module has been removed. Please use the corresponding functions in the `qml.math` 
+  and `qml.measurements` modules instead.
   [(#6584)](https://github.com/PennyLaneAI/pennylane/pull/6584)
 
 * Top level access to `Device`, `QubitDevice`, and `QutritDevice` have been removed. Instead, they
-  are available as `qml.devices.LegacyDevice`, `qml.devices.QubitDevice`, and `qml.devices.QutritDevice`
-  respectively.
+  are available as `qml.devices.LegacyDevice`, `qml.devices.QubitDevice`, and 
+  `qml.devices.QutritDevice`, respectively.
   [(#6537)](https://github.com/PennyLaneAI/pennylane/pull/6537)
 
-* The `'ancilla'` argument for `qml.iterative_qpe` has been removed. Instead, use the `'aux_wire'` argument.
+* The `'ancilla'` argument for `qml.iterative_qpe` has been removed. Instead, use the `'aux_wire'` 
+  argument.
   [(#6532)](https://github.com/PennyLaneAI/pennylane/pull/6532)
 
 * The `qml.BasisStatePreparation` template has been removed. Instead, use `qml.BasisState`.
   [(#6528)](https://github.com/PennyLaneAI/pennylane/pull/6528)
 
-* The `qml.workflow.set_shots` helper function has been removed. We no longer interact with the legacy device interface in our code.
-  Instead, shots should be specified on the tape, and the device should use these shots.
+* The `qml.workflow.set_shots` helper function has been removed. We no longer interact with the 
+  legacy device interface in our code. Instead, shots should be specified on the tape, and the 
+  device should use these shots.
   [(#6534)](https://github.com/PennyLaneAI/pennylane/pull/6534)
 
-* `QNode.gradient_fn` has been removed. Please use `QNode.diff_method` instead. `QNode.get_gradient_fn` can also be used to
-  process the diff method.
+* `QNode.gradient_fn` has been removed. Please use `QNode.diff_method` instead. 
+  `QNode.get_gradient_fn` can also be used to process the differentiation method.
   [(#6535)](https://github.com/PennyLaneAI/pennylane/pull/6535)
 
 * The `qml.QubitStateVector` template has been removed. Instead, use `qml.StatePrep`.
@@ -575,53 +1050,54 @@ following 4 sets of functions have been either moved or removed[(#6588)](https:/
   [(#6530)](https://github.com/PennyLaneAI/pennylane/pull/6530)
   [(#6561)](https://github.com/PennyLaneAI/pennylane/pull/6561)
 
+* The developer-facing ``qml.drawer.MPLDrawer`` argument `n_wires` has been replaced with `wire_map`,
+  which contains more complete information about wire labels and order. This allows the new functionality 
+  to specify `wire_options` for specific wires when using string wire labels or non-sequential wire ordering.
+  [(#6805)](https://github.com/PennyLaneAI/pennylane/pull/6805)
+
 <h3>Deprecations 👋</h3>
 
-* The `tape` and `qtape` properties of `QNode` have been deprecated.
-  Instead, use the `qml.workflow.construct_tape` function.
+* The `tape` and `qtape` properties of `QNode` have been deprecated. Instead, use the 
+  `qml.workflow.construct_tape` function.
   [(#6583)](https://github.com/PennyLaneAI/pennylane/pull/6583)
   [(#6650)](https://github.com/PennyLaneAI/pennylane/pull/6650)
 
-* The `max_expansion` argument in `qml.devices.preprocess.decompose` is deprecated and will be removed in v0.41.
+* The `max_expansion` argument in `qml.devices.preprocess.decompose` is deprecated and will be 
+  removed in v0.41.
   [(#6400)](https://github.com/PennyLaneAI/pennylane/pull/6400)
 
-* The `decomp_depth` argument in `qml.transforms.set_decomposition` is deprecated and will be removed in v0.41.
+* The `decomp_depth` argument in `qml.transforms.set_decomposition` is deprecated and will be 
+  removed in v0.41.
   [(#6400)](https://github.com/PennyLaneAI/pennylane/pull/6400)
 
-* The `output_dim` property of `qml.tape.QuantumScript` has been deprecated.
-Instead, use method `shape` of `QuantumScript` or `MeasurementProcess` to get the
-same information.
+* The `output_dim` property of `qml.tape.QuantumScript` has been deprecated. Instead, use method 
+  `shape` of `QuantumScript` or `MeasurementProcess` to get the same information.
   [(#6577)](https://github.com/PennyLaneAI/pennylane/pull/6577)
 
-* The `QNode.get_best_method` and `QNode.best_method_str` methods have been deprecated.
-  Instead, use the `qml.workflow.get_best_diff_method` function.
+* The `QNode.get_best_method` and `QNode.best_method_str` methods have been deprecated. Instead, use 
+  the `qml.workflow.get_best_diff_method` function.
   [(#6418)](https://github.com/PennyLaneAI/pennylane/pull/6418)
 
-* The `qml.execute` `gradient_fn` keyword argument has been renamed `diff_method`,
-  to better align with the termionology used by the `QNode`.
-  `gradient_fn` will be removed in v0.41.
+* The `qml.execute` `gradient_fn` keyword argument has been renamed to `diff_method` to better 
+  align with the termionology used by the QNode. `gradient_fn` will be removed in v0.41.
   [(#6549)](https://github.com/PennyLaneAI/pennylane/pull/6549)
 
+* The old `qml.qsvt` functionality is moved to `qml.qsvt_legacy`
+  and is now deprecated. It will be removed in v0.41.
+  [(#6520)](https://github.com/PennyLaneAI/pennylane/pull/6520)
+  
+
 <h3>Documentation 📝</h3>
 
-* The docstrings for `qml.qchem.Molecule` and `qml.qchem.molecular_hamiltonian` have been updated to include a 
-  note that says that they are not compatible with qjit or jit.  
+* The docstrings for `qml.qchem.Molecule` and `qml.qchem.molecular_hamiltonian` have been updated to 
+  include a note that says that they are not compatible with `qjit` or `jit`.  
   [(#6702)](https://github.com/PennyLaneAI/pennylane/pull/6702)
 
-* Updated the documentation of `TrotterProduct` to include the impact of the operands in the
-  Hamiltonian on the strucutre of the created circuit. Included an illustrative example on this.
+* The documentation of `TrotterProduct` has been updated to include the impact of the operands in 
+  the Hamiltonian on the structure of the created circuit.
   [(#6629)](https://github.com/PennyLaneAI/pennylane/pull/6629)
 
-* Add reporting of test warnings as failures.
-  [(#6217)](https://github.com/PennyLaneAI/pennylane/pull/6217)
-
-* Add a warning message to Gradients and training documentation about ComplexWarnings.
-  [(#6543)](https://github.com/PennyLaneAI/pennylane/pull/6543)
-
-* Added `opengraph.png` asset and configured `opengraph` metadata image. Overrode the documentation landing page `meta-description`.
-  [(#6696)](https://github.com/PennyLaneAI/pennylane/pull/6696)
-
-* Updated the documentation of `QSVT` to include examples for different block encodings.
+* The documentation of `QSVT` has been updated to include examples for different block encodings.
   [(#6673)](https://github.com/PennyLaneAI/pennylane/pull/6673)
 
 * The link to `qml.ops.one_qubit_transform` was fixed in the `QubitUnitary` docstring.
@@ -629,42 +1105,44 @@ same information.
 
 <h3>Bug fixes 🐛</h3>
 
-* Adds validation so the device vjp is only used when the device actually supports it.
+* Validation has been added to ensure that the device vjp is only used when the device actually 
+  supports it.
   [(#6755)](https://github.com/PennyLaneAI/pennylane/pull/6755/)
 
-* `qml.counts` returns all outcomes when the `all_outcomes` argument is `True` and mid-circuit measurements are present.
+* `qml.counts` now returns all outcomes when the `all_outcomes` argument is `True` and mid-circuit 
+  measurements are present.
   [(#6732)](https://github.com/PennyLaneAI/pennylane/pull/6732)
 
-* `qml.ControlledQubitUnitary` has consistent behaviour with program capture enabled. 
+* `qml.ControlledQubitUnitary` now has consistent behaviour with program capture enabled. 
   [(#6719)](https://github.com/PennyLaneAI/pennylane/pull/6719)
 
-* The `Wires` object throws a `TypeError` if `wires=None`. 
+* The `Wires` object now throws a `TypeError` if `wires=None`. 
   [(#6713)](https://github.com/PennyLaneAI/pennylane/pull/6713)
   [(#6720)](https://github.com/PennyLaneAI/pennylane/pull/6720)
 
-* The `qml.Hermitian` class no longer checks that the provided matrix is hermitian.
-  The reason for this removal is to allow for faster execution and avoid incompatibilities with `jax.jit`.
+* The `qml.Hermitian` class no longer checks that the provided matrix is hermitian. The reason for
+  this removal is to allow for faster execution and avoid incompatibilities with `jax.jit`.
   [(#6642)](https://github.com/PennyLaneAI/pennylane/pull/6642)
 
-* Subclasses of `qml.ops.Controlled` no longer bind the primitives of their base operators when program capture
-  is enabled.
+* Subclasses of `qml.ops.Controlled` no longer bind the primitives of their base operators when 
+  program capture is enabled.
   [(#6672)](https://github.com/PennyLaneAI/pennylane/pull/6672)
 
 * The `qml.HilbertSchmidt` and `qml.LocalHilbertSchmidt` templates now apply the complex conjugate
   of the unitaries instead of the adjoint, providing the correct result.
   [(#6604)](https://github.com/PennyLaneAI/pennylane/pull/6604)
 
-* `QNode` return behaviour is now consistent for lists and tuples.
+* QNode return behaviour is now consistent for lists and tuples.
   [(#6568)](https://github.com/PennyLaneAI/pennylane/pull/6568)
 
-* `qml.QNode` now accepts arguments with types defined in libraries that are not necessarily
-  in the list of supported interfaces, such as the `Graph` class defined in `networkx`.
+* QNodes now accept arguments with types defined in libraries that are not necessarily in the list 
+  of supported interfaces, such as the `Graph` class defined in `networkx`.
   [(#6600)](https://github.com/PennyLaneAI/pennylane/pull/6600)
 
-* `qml.math.get_deep_interface` now works properly for autograd arrays.
+* `qml.math.get_deep_interface` now works properly for Autograd arrays.
   [(#6557)](https://github.com/PennyLaneAI/pennylane/pull/6557)
 
-* Fixed `Identity.__repr__` to return correct wires list.
+* Printing instances of `qml.Identity` now returns the correct wires list.
   [(#6506)](https://github.com/PennyLaneAI/pennylane/pull/6506)
 
 <h3>Contributors ✍️</h3>
@@ -692,4 +1170,4 @@ Anton Naim Ibrahim,
 Andrija Paurevic,
 Justin Pickering,
 Jay Soni,
-David Wierichs.
+David Wierichs.
\ No newline at end of file
diff --git a/pennylane/bose/bosonic_mapping.py b/pennylane/bose/bosonic_mapping.py
index 87112648b..01f34b3cd 100644
--- a/pennylane/bose/bosonic_mapping.py
+++ b/pennylane/bose/bosonic_mapping.py
@@ -51,8 +51,8 @@ def binary_mapping(
     The mapping procedure is described in equations :math:`27-29` in `arXiv:1507.03271 <https://arxiv.org/pdf/1507.03271>`_.
 
     Args:
-        bose_operator(BoseWord, BoseSentence): the bosonic operator
-        n_states(int): maximum number of allowed bosonic states
+        bose_operator (BoseWord, BoseSentence): the bosonic operator
+        n_states (int): Maximum number of allowed bosonic states. Defaults to ``2``.
         ps (bool): Whether to return the result as a ``PauliSentence`` instead of an
             operator. Defaults to ``False``.
         wire_map (dict): A dictionary defining how to map the states of
@@ -61,7 +61,7 @@ def binary_mapping(
         tol (float): tolerance for discarding the imaginary part of the coefficients
 
     Returns:
-        Union[PauliSentence, Operator]: A linear combination of qubit operators
+        Union[PauliSentence, Operator]: a linear combination of qubit operators
 
     **Example**
 
@@ -177,16 +177,16 @@ def unary_mapping(
 
     Args:
         bose_operator(BoseWord, BoseSentence): the bosonic operator
-        n_states(int): maximum number of allowed bosonic states
-        ps (bool): Whether to return the result as a PauliSentence instead of an
-            operator. Defaults to False.
+        n_states(int): Maximum number of allowed bosonic states. Defaults to ``2``.
+        ps (bool): Whether to return the result as a ``PauliSentence`` instead of an
+            operator. Defaults to ``False``.
         wire_map (dict): A dictionary defining how to map the states of
-            the Bose operator to qubit wires. If None, integers used to
-            label the bosonic states will be used as wire labels. Defaults to None.
+            the Bose operator to qubit wires. If ``None``, integers used to
+            label the bosonic states will be used as wire labels. Defaults to ``None``.
         tol (float): tolerance for discarding the imaginary part of the coefficients
 
     Returns:
-        Union[PauliSentence, Operator]: A linear combination of qubit operators.
+        Union[PauliSentence, Operator]: a linear combination of qubit operators
 
     **Example**
 
@@ -329,11 +329,11 @@ def christiansen_mapping(
 
     Args:
         bose_operator(BoseWord, BoseSentence): the bosonic operator
-        ps (bool): Whether to return the result as a PauliSentence instead of an
-            operator. Defaults to False.
+        ps (bool): Whether to return the result as a ``PauliSentence`` instead of an
+            operator. Defaults to ``False``.
         wire_map (dict): A dictionary defining how to map the states of
-            the Bose operator to qubit wires. If None, integers used to
-            label the bosonic states will be used as wire labels. Defaults to None.
+            the Bose operator to qubit wires. If ``None``, integers used to
+            label the bosonic states will be used as wire labels. Defaults to ``None``.
         tol (float): tolerance for discarding the imaginary part of the coefficients
 
     Returns:
diff --git a/pennylane/capture/autograph/transformer.py b/pennylane/capture/autograph/transformer.py
index 685bdb00f..ce859a955 100644
--- a/pennylane/capture/autograph/transformer.py
+++ b/pennylane/capture/autograph/transformer.py
@@ -125,8 +125,8 @@ def run_autograph(fn):
     ).
 
     Args:
-        fn (Callable): the callable to be converted. This could be a function, a QNode, or another callable object.
-            For a QNode, the ``Qnode.func`` will be converted. For another callable object, a function calling the
+        fn (Callable): The callable to be converted. This could be a function, a QNode, or another callable object.
+            For a QNode, the ``QNode.func`` will be converted. For another callable object, a function calling the
             object will be converted.
 
     Returns:
diff --git a/pennylane/capture/base_interpreter.py b/pennylane/capture/base_interpreter.py
index b23f6be3e..4af11cb61 100644
--- a/pennylane/capture/base_interpreter.py
+++ b/pennylane/capture/base_interpreter.py
@@ -84,13 +84,14 @@ class PlxprInterpreter:
 
     Now the interpreter can be used to transform functions and jaxpr:
 
+    >>> qml.capture.enable()
     >>> interpreter = SimplifyInterpreter()
     >>> def f(x):
     ...     qml.RX(x, 0)**2
     ...     qml.adjoint(qml.Z(0))
     ...     return qml.expval(qml.X(0) + qml.X(0))
     >>> simplified_f = interpreter(f)
-    >>> print(qml.draw(simplified_f)(0.5)
+    >>> print(qml.draw(simplified_f)(0.5))
     0: ──RX(1.00)──Z─┤  <2.00*X>
     >>> jaxpr = jax.make_jaxpr(f)(0.5)
     >>> interpreter.eval(jaxpr.jaxpr, [], 0.5)
@@ -98,13 +99,12 @@ class PlxprInterpreter:
 
     **Handling higher order primitives:**
 
-    Two main strategies exist for handling higher order primitives (primitives with jaxpr as metatdata).
-
-    1) Structure preserving. Tracing the execution preserves the higher order primitive.
-    2) Structure flattening. Tracing the execution eliminates the higher order primitive.
+    Two main strategies exist for handling higher order primitives (primitives with jaxpr as metadata).
+    The first one is structure preserving (tracing the execution preserves the higher order primitive),
+    and the second one is structure flattening (tracing the execution eliminates the higher order primitive).
 
     Compilation transforms, like the above ``SimplifyInterpreter``, may prefer to handle higher order primitives
-    via a structure preserving method. After transforming the jaxpr, the `for_loop` still exists. This maintains
+    via a structure-preserving method. After transforming the jaxpr, the `for_loop` still exists. This maintains
     the compact structure of the jaxpr and reduces the size of the program. This behavior is the default.
 
     >>> def g(x):
@@ -117,23 +117,26 @@ class PlxprInterpreter:
     >>> jax.make_jaxpr(interpreter(g))(0.5)
     { lambda ; a:f32[]. let
         _:f32[] = for_loop[
-        jaxpr_body_fn={ lambda ; b:i32[] c:f32[]. let
+          args_slice=slice(0, None, None)
+          consts_slice=slice(0, 0, None)
+          jaxpr_body_fn={ lambda ; b:i32[] c:f32[]. let
             d:f32[] = convert_element_type[new_dtype=float32 weak_type=True] b
             e:f32[] = mul c d
             _:AbstractOperator() = RX[n_wires=1] e 0
-            in (c,) }
-        n_consts=0
+          in (c,) }
         ] 0 3 1 1.0
         f:AbstractOperator() = PauliZ[n_wires=1] 0
         g:AbstractOperator() = SProd[_pauli_rep=4.0 * Z(0)] 4.0 f
         h:AbstractMeasurement(n_wires=None) = expval_obs g
-    in (h,) }
+      in (h,) }
 
     Accumulation transforms, like device execution or conversion to tapes, may need to flatten out
     the higher order primitive to execute it.
 
     .. code-block:: python
 
+        import copy
+
         class AccumulateOps(PlxprInterpreter):
 
             def __init__(self, ops=None):
@@ -152,14 +155,14 @@ class PlxprInterpreter:
             state = invals[args_slice]
 
             for i in range(start, stop, step):
-                state = copy(self).eval(jaxpr_body_fn, consts, i, *state)
+                state = copy.copy(self).eval(jaxpr_body_fn, consts, i, *state)
             return state
 
     >>> @qml.for_loop(3)
     ... def loop(i, x):
     ...     qml.RX(x, i)
     ...     return x
-    >>> accumulator = AccumlateOps()
+    >>> accumulator = AccumulateOps()
     >>> accumulator(loop)(0.5)
     >>> accumulator.ops
     [RX(0.5, wires=[0]), RX(0.5, wires=[1]), RX(0.5, wires=[2])]
@@ -222,7 +225,7 @@ class PlxprInterpreter:
     def cleanup(self) -> None:
         """Perform any final steps after iterating through all equations.
 
-        Blank by default, this method can clean up instance variables. Particularily,
+        Blank by default, this method can clean up instance variables. Particularly,
         this method can be used to deallocate qubits and registers when converting to
         a Catalyst variant jaxpr.
         """
diff --git a/pennylane/debugging/snapshot.py b/pennylane/debugging/snapshot.py
index 84ee2d173..430ba08f4 100644
--- a/pennylane/debugging/snapshot.py
+++ b/pennylane/debugging/snapshot.py
@@ -72,7 +72,7 @@ def snapshots(tape: QuantumScript) -> tuple[QuantumScriptBatch, PostprocessingFn
 
     If tape splitting is carried out, the transform will be conservative about the wires that it includes in each tape.
     So, if all operations preceding a snapshot in a 3-qubit circuit has been applied to only one wire,
-    the tape would only be looking at this wire. This can be overriden by the configuration of the execution device
+    the tape would only be looking at this wire. This can be overridden by the configuration of the execution device
     and its nature.
 
     Regardless of the transform's behaviour, the output is a dictionary where each key is either
diff --git a/pennylane/devices/__init__.py b/pennylane/devices/__init__.py
index 463f6c3f1..40546c10b 100644
--- a/pennylane/devices/__init__.py
+++ b/pennylane/devices/__init__.py
@@ -24,6 +24,7 @@ to verify and test quantum gradient computations.
 .. autosummary::
     :toctree: api
 
+    capabilities
     default_qubit
     default_gaussian
     default_mixed
diff --git a/pennylane/devices/_qubit_device.py b/pennylane/devices/_qubit_device.py
index e777cecea..148b4331d 100644
--- a/pennylane/devices/_qubit_device.py
+++ b/pennylane/devices/_qubit_device.py
@@ -634,7 +634,7 @@ class QubitDevice(Device):
         results = []
 
         for m in measurements:
-            # TODO: Remove this when all overriden measurements support the `MeasurementProcess` class
+            # TODO: Remove this when all overridden measurements support the `MeasurementProcess` class
             if isinstance(m.mv, list):
                 # MeasurementProcess stores information needed for processing if terminal measurement
                 # uses a list of mid-circuit measurement values
@@ -642,7 +642,7 @@ class QubitDevice(Device):
             else:
                 obs = m.obs or m.mv
                 obs = m if obs is None else obs
-            # Check if there is an overriden version of the measurement process
+            # Check if there is an overridden version of the measurement process
             if method := getattr(self, self.measurement_map[type(m)], False):
                 if isinstance(m, MeasurementTransform):
                     result = method(tape=circuit)
diff --git a/pennylane/devices/capabilities.py b/pennylane/devices/capabilities.py
index bbe6614ae..da1cc5aa5 100644
--- a/pennylane/devices/capabilities.py
+++ b/pennylane/devices/capabilities.py
@@ -56,19 +56,19 @@ VALID_CONDITION_STRINGS = {condition.value for condition in ExecutionCondition}
 
 @dataclass
 class OperatorProperties:
-    """Information about support for each operation.
-
-    Attributes:
-        invertible (bool): Whether the adjoint of the operation is also supported.
-        controllable (bool): Whether the operation can be controlled.
-        differentiable (bool): Whether the operation is supported for device gradients.
-        conditions (list[ExecutionCondition]): Execution conditions that the operation must meet.
-    """
+    """Information about support for each operation."""
 
     invertible: bool = False
+    """Whether the adjoint of the operation is also supported."""
+
     controllable: bool = False
+    """Whether the operation can be controlled."""
+
     differentiable: bool = False
+    """Whether the operation is supported for device gradients."""
+
     conditions: list[ExecutionCondition] = field(default_factory=list)
+    """Execution conditions that the operation must meet."""
 
     def __and__(self, other: "OperatorProperties") -> "OperatorProperties":
         # Take the intersection of support but the union of constraints (conditions)
@@ -103,31 +103,37 @@ def _get_supported_base_op(op_name: str, op_dict: dict[str, OperatorProperties])
 
 @dataclass
 class DeviceCapabilities:  # pylint: disable=too-many-instance-attributes
-    """Capabilities of a quantum device.
-
-    Attributes:
-        operations: Operations natively supported by the backend device.
-        observables: Observables that the device can measure.
-        measurement_processes: List of measurement processes supported by the backend device.
-        qjit_compatible (bool): Whether the device is compatible with qjit.
-        runtime_code_generation (bool): Whether the device requires run time generation of the quantum circuit.
-        dynamic_qubit_management (bool): Whether the device supports dynamic qubit allocation/deallocation.
-        overlapping_observables (bool): Whether the device supports measuring overlapping observables on the same tape.
-        non_commuting_observables (bool): Whether the device supports measuring non-commuting observables on the same tape.
-        initial_state_prep (bool): Whether the device supports initial state preparation.
-        supported_mcm_methods (list[str]): List of supported methods of mid-circuit measurements.
-    """
+    """Capabilities of a quantum device."""
 
     operations: dict[str, OperatorProperties] = field(default_factory=dict)
+    """Operations natively supported by the backend device."""
+
     observables: dict[str, OperatorProperties] = field(default_factory=dict)
+    """Observables that the device can measure."""
+
     measurement_processes: dict[str, list[ExecutionCondition]] = field(default_factory=dict)
+    """List of measurement processes supported by the backend device."""
+
     qjit_compatible: bool = False
+    """Whether the device is compatible with qjit."""
+
     runtime_code_generation: bool = False
+    """Whether the device requires run time generation of the quantum circuit."""
+
     dynamic_qubit_management: bool = False
+    """Whether the device supports dynamic qubit allocation/deallocation."""
+
     overlapping_observables: bool = True
+    """Whether the device supports measuring overlapping observables on the same tape."""
+
     non_commuting_observables: bool = False
+    """Whether the device supports measuring non-commuting observables on the same tape."""
+
     initial_state_prep: bool = False
+    """Whether the device supports initial state preparation."""
+
     supported_mcm_methods: list[str] = field(default_factory=list)
+    """List of supported methods of mid-circuit measurements."""
 
     def filter(self, finite_shots: bool) -> "DeviceCapabilities":
         """Returns the device capabilities conditioned on the given program features."""
@@ -162,8 +168,8 @@ class DeviceCapabilities:  # pylint: disable=too-many-instance-attributes
         Args:
             file_path (str): The path to the TOML file.
             runtime_interface (str): The runtime execution interface to get the capabilities for.
-                Acceptable values are "pennylane" and "qjit". Use "pennylane" for capabilities of
-                the device's implementation of `Device.execute`, and "qjit" for capabilities of
+                Acceptable values are ``"pennylane"`` and ``"qjit"``. Use ``"pennylane"`` for capabilities of
+                the device's implementation of `Device.execute`, and ``"qjit"`` for capabilities of
                 the runtime execution function used by a qjit-compiled workflow.
 
         """
@@ -356,7 +362,7 @@ def parse_toml_document(document: dict) -> DeviceCapabilities:
     """Parses a TOML document into a DeviceCapabilities object.
 
     This function will ignore sections that are specific to either runtime interface, such as
-    "qjit.operators.gates". To include these sections, use :func:`update_device_capabilities`
+    ``"qjit.operators.gates"``. To include these sections, use :func:`update_device_capabilities`
     on the capabilities object returned from this function.
 
     """
@@ -429,7 +435,7 @@ def observable_stopping_condition_factory(
 
 
 def validate_mcm_method(capabilities: DeviceCapabilities, mcm_method: str, shots_present: bool):
-    """Validates an MCM method against the device's capabilities.'"""
+    """Validates an MCM method against the device's capabilities."""
 
     if mcm_method is None or mcm_method == "deferred":
         return  # no need to validate if requested deferred or if no method is requested.
diff --git a/pennylane/devices/default_clifford.py b/pennylane/devices/default_clifford.py
index 11eaec5c5..773de2fcf 100644
--- a/pennylane/devices/default_clifford.py
+++ b/pennylane/devices/default_clifford.py
@@ -579,7 +579,7 @@ class DefaultClifford(Device):
         tableau_simulator.do_circuit(stim_circuit)
         global_phase = qml.GlobalPhase(qml.math.sum(op.data[0] for op in global_phase_ops))
 
-        # Perform measurments based on whether shots are provided
+        # Perform measurements based on whether shots are provided
         if circuit.shots:
             meas_results = self.measure_statistical(circuit, stim_circuit, seed=seed)
         else:
diff --git a/pennylane/devices/default_tensor.py b/pennylane/devices/default_tensor.py
index cb19f625d..100953c37 100644
--- a/pennylane/devices/default_tensor.py
+++ b/pennylane/devices/default_tensor.py
@@ -258,8 +258,18 @@ class DefaultTensor(Device):
     We can provide additional keyword arguments to the device to customize the simulation. These are passed to the ``quimb`` backend.
 
     .. note::
-        Be aware that `quimb` uses multi-threading with `numba <https://numba.pydata.org/numba-doc/dev/user/threading-layer.html>`_ as well as for linear algebra operations with `numpy.linalg <https://numpy.org/doc/stable/reference/routines.linalg.html#linear-algebra-numpy-linalg>`_. Proper setting of the corresponding environment variables (e.g. `OMP_NUM_THREADS`, `OPENBLAS_NUM_THREADS`, `NUMBA_NUM_THREADS` etc.) depending on your hardware is highly recommended and will have a strong impact on the device's performance.
-        To avoid a slowdown in performance for circuits with more than 10 wires, we recommend setting the environment variable relevant for your BLAS library backend (e.g. `OMP_NUM_THREADS=1`, `OPENBLAS_NUM_THREADS=1` or `MKL_NUM_THREADS=1`), depending on your NumPy package & associated libraries. Alternatively, you can use  `threadpoolctl <https://github.com/joblib/threadpoolctl>`_  to limit the threads within your executing script. For optimal performance you can adjust the number of threads to find the best fit for your workload.
+
+        Be aware that ``quimb`` uses multi-threading with `numba <https://numba.pydata.org/numba-doc/dev/user/threading-layer.html>`_
+        as well as for linear algebra operations with
+        `numpy.linalg <https://numpy.org/doc/stable/reference/routines.linalg.html#linear-algebra-numpy-linalg>`_. Proper setting of
+        the corresponding environment variables (e.g. ``OMP_NUM_THREADS``, ``OPENBLAS_NUM_THREADS``, ``NUMBA_NUM_THREADS`` etc.)
+        depending on your hardware is highly recommended and will have a strong impact on the device's performance.
+
+        To avoid a slowdown in performance for circuits with more than 10 wires, we recommend setting the environment variable relevant
+        for your BLAS library backend (e.g. ``OMP_NUM_THREADS=1``, ``OPENBLAS_NUM_THREADS=1`` or ``MKL_NUM_THREADS=1``), depending on your
+        NumPy package and associated libraries. Alternatively, you can use `threadpoolctl <https://github.com/joblib/threadpoolctl>`_ to
+        limit the threads within your executing script. For optimal performance you can adjust the number of threads to find the best fit
+        for your workload.
 
     .. details::
             :title: Usage with MPS Method
@@ -403,7 +413,7 @@ class DefaultTensor(Device):
         # options for TN
         self._local_simplify = kwargs.get("local_simplify", "ADCRS")
 
-        # options both for MPS and TN
+        # options for both MPS and TN
         self._contraction_optimizer = kwargs.get("contraction_optimizer", "auto-hq")
         self._contract = None
 
diff --git a/pennylane/devices/device_api.py b/pennylane/devices/device_api.py
index 3969a3f01..de9eaad67 100644
--- a/pennylane/devices/device_api.py
+++ b/pennylane/devices/device_api.py
@@ -655,7 +655,7 @@ class Device(abc.ABC):
             >>> dev.execute([tape])
             (array(1.0),)
 
-            If the script has multiple measurments, then the device should return a tuple of measurements.
+            If the script has multiple measurements, then the device should return a tuple of measurements.
 
             >>> tape = qml.tape.QuantumTape(measurements=[qml.expval(qml.Z(0)), qml.probs(wires=(0,1))])
             >>> tape.shape(dev)
diff --git a/pennylane/devices/execution_config.py b/pennylane/devices/execution_config.py
index fc953a2dc..2cf78cee3 100644
--- a/pennylane/devices/execution_config.py
+++ b/pennylane/devices/execution_config.py
@@ -26,7 +26,7 @@ class MCMConfig:
     """A class to store mid-circuit measurement configurations."""
 
     mcm_method: Optional[str] = None
-    """Which mid-circuit measurement strategy to use. Use ``"deferred"`` for the deferred
+    """The mid-circuit measurement strategy to use. Use ``"deferred"`` for the deferred
     measurements principle and ``"one-shot"`` if using finite shots to execute the circuit for
     each shot separately. Any other value will be passed to the device, and the device is
     expected to handle mid-circuit measurements using the requested method. If not specified,
@@ -34,7 +34,7 @@ class MCMConfig:
 
     postselect_mode: Optional[str] = None
     """How postselection is handled with finite-shots. If ``"hw-like"``, invalid shots will be
-    discarded and only results for valid shots will be returned. In this case, less samples
+    discarded and only results for valid shots will be returned. In this case, fewer samples
     may be returned than the original number of shots. If ``"fill-shots"``, the returned samples
     will be of the same size as the original number of shots. If not specified, the device will
     decide which mode to use. Note that internally ``"pad-invalid-samples"`` is used internally
diff --git a/pennylane/devices/qubit_mixed/apply_operation.py b/pennylane/devices/qubit_mixed/apply_operation.py
index aa6caa8ba..a5417bb4b 100644
--- a/pennylane/devices/qubit_mixed/apply_operation.py
+++ b/pennylane/devices/qubit_mixed/apply_operation.py
@@ -325,7 +325,7 @@ def apply_operation(
     .. code-block:: python
 
         @apply_operation.register
-        def _(op: type_op, state):
+        def _(op: type_op, state, is_state_batched=False, **kwargs):
             # custom op application method here
 
     **Example:**
diff --git a/pennylane/devices/qubit_mixed/measure.py b/pennylane/devices/qubit_mixed/measure.py
index 092845948..cb6611742 100644
--- a/pennylane/devices/qubit_mixed/measure.py
+++ b/pennylane/devices/qubit_mixed/measure.py
@@ -197,7 +197,7 @@ def calculate_variance(
         to simulate readout errors.
 
     Returns:
-        TensorLike: the variance of the observable wrt the state.
+        TensorLike: the variance of the observable with respect to the state.
     """
     probs = calculate_probability(measurementprocess, state, is_state_batched, readout_errors)
     eigvals = math.asarray(measurementprocess.eigvals(), dtype="float64")
@@ -222,7 +222,7 @@ def calculate_expval_sum_of_terms(
         to simulate readout errors.
 
     Returns:
-        TensorLike: the expectation value of the sum of Hamiltonian observable wrt the state.
+        TensorLike: the expectation value of the sum of Hamiltonian observable with respect to the state.
     """
     # Recursively call measure on each term, so that the best measurement method can
     # be used for each term
diff --git a/pennylane/devices/qubit_mixed/sampling.py b/pennylane/devices/qubit_mixed/sampling.py
index 585977cef..ed165dca5 100644
--- a/pennylane/devices/qubit_mixed/sampling.py
+++ b/pennylane/devices/qubit_mixed/sampling.py
@@ -105,7 +105,7 @@ def _measure_with_samples_diagonalizing_gates(
 
     Args:
         mp (~.measurements.SampleMeasurement): The sample measurement to perform
-        state (TensorLike): The state vector to sample from
+        state (TensorLike): The density matrix to sample from
         shots (~.measurements.Shots): The number of samples to take
         is_state_batched (bool): whether the state is batched or not
         rng (Union[None, int, array_like[int], SeedSequence, BitGenerator, Generator]): A
@@ -224,7 +224,7 @@ def sample_state(
     """Returns a series of computational basis samples of a state.
 
     Args:
-        state (array[complex]): A state vector to be sampled
+        state (array[complex]): A density matrix to be sampled
         shots (int): The number of samples to take
         is_state_batched (bool): whether the state is batched or not
         wires (Sequence[int]): The wires to sample
@@ -271,7 +271,7 @@ def measure_with_samples(
 
     Args:
         mp (SampleMeasurement): The sample measurement to perform
-        state (np.ndarray[complex]): The state vector to sample from
+        state (np.ndarray[complex]): The density matrix to sample from
         shots (Shots): The number of samples to take
         is_state_batched (bool): whether the state is batched or not
         rng (Union[None, int, array_like[int], SeedSequence, BitGenerator, Generator]): A
diff --git a/pennylane/devices/qubit_mixed/simulate.py b/pennylane/devices/qubit_mixed/simulate.py
index 426f1d2a2..392a1919d 100644
--- a/pennylane/devices/qubit_mixed/simulate.py
+++ b/pennylane/devices/qubit_mixed/simulate.py
@@ -55,7 +55,7 @@ def get_final_state(circuit, debugger=None, interface=None, **kwargs):
         interface (str): The machine learning interface to create the initial state with
 
     Returns:
-        Tuple[TensorLike, bool]: A tuple containing the final state of the quantum script and
+        tuple[TensorLike, bool]: A tuple containing the final state of the quantum script and
             whether the state has a batch dimension.
 
     """
diff --git a/pennylane/drawer/mpldrawer.py b/pennylane/drawer/mpldrawer.py
index 64e92a50c..d3b089317 100644
--- a/pennylane/drawer/mpldrawer.py
+++ b/pennylane/drawer/mpldrawer.py
@@ -25,6 +25,8 @@ try:
 except (ModuleNotFoundError, ImportError) as e:  # pragma: no cover
     has_mpl = False
 
+# pylint: disable=too-many-positional-arguments
+
 
 def _to_tuple(a):
     """Converts int or iterable to tuple"""
@@ -63,20 +65,20 @@ class MPLDrawer:
 
     Args:
         n_layers (int): the number of layers
-        n_wires (int): the number of wires
+        wire_map (dict): the wires to be drawn. A dict mapping wire label to index (from top to bottom) in the figure
 
     Keyword Args:
         c_wires=0 (int): the number of classical wires to leave space for.
         wire_options=None (dict): matplotlib configuration options for drawing the wire lines
         figsize=None (Iterable): Allows users to specify the size of the figure manually. Defaults
-            to scale with the size of the circuit via ``n_layers`` and ``n_wires``.
+            to scale with the size of the circuit via ``n_layers`` and ``len(wire_map)``.
         fig=None (matplotlib Figure): Allows users to specify the figure window to plot to.
 
     **Example**
 
     .. code-block:: python
 
-        drawer = qml.drawer.MPLDrawer(n_wires=5, n_layers=6)
+        drawer = qml.drawer.MPLDrawer(wire_map={i: i for i in range(5)}, n_layers=6)
 
         drawer.label(["0", "a", r"$|\Psi\rangle$", r"$|\theta\rangle$", "aux"])
 
@@ -165,7 +167,7 @@ class MPLDrawer:
     .. code-block:: python
 
         wire_options = {"color": "indigo", "linewidth": 4}
-        drawer = MPLDrawer(n_wires=2, n_layers=4, wire_options=wire_options)
+        drawer = MPLDrawer(wire_map={0: 0, 1: 1}, n_layers=4, wire_options=wire_options)
 
         label_options = {"fontsize": "x-large", 'color': 'indigo'}
         drawer.label(["0", "a"], text_options=label_options)
@@ -203,7 +205,7 @@ class MPLDrawer:
 
     .. code-block:: python
 
-        drawer = MPLDrawer(2, 2)
+        drawer = MPLDrawer(2, {0:0, 1:1})
         drawer.box_gate(layer=0, wires=1, text="X")
         drawer.box_gate(layer=1, wires=1, text="Y")
 
@@ -255,7 +257,7 @@ class MPLDrawer:
     _cwire_scaling = 0.25
     """The distance between successive control wires."""
 
-    def __init__(self, n_layers, n_wires, c_wires=0, wire_options=None, figsize=None, fig=None):
+    def __init__(self, n_layers, wire_map, c_wires=0, wire_options=None, figsize=None, fig=None):
         if not has_mpl:  # pragma: no cover
             raise ImportError(
                 "Module matplotlib is required for ``MPLDrawer`` class. "
@@ -263,7 +265,7 @@ class MPLDrawer:
             )
 
         self.n_layers = n_layers
-        self.n_wires = n_wires
+        self.n_wires = len(wire_map)
 
         ## Creating figure and ax
 
@@ -300,14 +302,14 @@ class MPLDrawer:
 
         # Adding wire lines with individual styles based on wire_options
         self._wire_lines = []
-        for wire in range(self.n_wires):
-            specific_options = wire_specific_options.get(wire, {})
+        for wire_label, idx in wire_map.items():
+            specific_options = wire_specific_options.get(wire_label, {})
             line_options = {**global_options, **specific_options}
 
             # Create Line2D with the combined options
             line = plt.Line2D(
                 (-1, self.n_layers),
-                (wire, wire),
+                (idx, idx),
                 zorder=1,
                 **line_options,
             )
@@ -349,7 +351,7 @@ class MPLDrawer:
 
         .. code-block:: python
 
-            drawer = MPLDrawer(n_wires=2, n_layers=1)
+            drawer = MPLDrawer(wire_map={0:0, 1:1}, n_layers=1)
             drawer.label(["a", "b"])
 
         .. figure:: ../../_static/drawer/labels.png
@@ -363,7 +365,7 @@ class MPLDrawer:
 
         .. code-block:: python
 
-            drawer = MPLDrawer(n_wires=2, n_layers=1)
+            drawer = MPLDrawer(wire_map={0:0, 1:1}, n_layers=1)
             drawer.label(["a", "b"], text_options={"color": "indigo", "fontsize": "xx-large"})
 
         .. figure:: ../../_static/drawer/labels_formatted.png
@@ -419,7 +421,7 @@ class MPLDrawer:
 
         .. code-block:: python
 
-            drawer = MPLDrawer(n_wires=2, n_layers=1)
+            drawer = MPLDrawer(wire_map={0:0, 1:1}, n_layers=1)
 
             drawer.box_gate(layer=0, wires=(0, 1), text="CY")
 
@@ -441,7 +443,7 @@ class MPLDrawer:
             box_options = {'facecolor': 'lightcoral', 'edgecolor': 'maroon', 'linewidth': 5}
             text_options = {'fontsize': 'xx-large', 'color': 'maroon'}
 
-            drawer = MPLDrawer(n_wires=2, n_layers=1)
+            drawer = MPLDrawer(wire_map={0:0, 1:1}, n_layers=1)
 
             drawer.box_gate(layer=0, wires=(0, 1), text="CY",
                 box_options=box_options, text_options=text_options)
@@ -456,7 +458,7 @@ class MPLDrawer:
 
         .. code-block:: python
 
-            drawer = MPLDrawer(n_layers=4, n_wires=2)
+            drawer = MPLDrawer(n_layers=4, wire_map={0:0, 1:1})
 
             drawer.box_gate(layer=0, wires=0, text="A longer label")
             drawer.box_gate(layer=0, wires=1, text="Label")
@@ -615,7 +617,7 @@ class MPLDrawer:
 
         .. code-block:: python
 
-            drawer = MPLDrawer(n_wires=2, n_layers=3)
+            drawer = MPLDrawer(wire_map={0:0, 1:1}, n_layers=3)
 
             drawer.ctrl(layer=0, wires=0, wires_target=1)
             drawer.ctrl(layer=1, wires=(0, 1), control_values=[0, 1])
@@ -714,7 +716,7 @@ class MPLDrawer:
 
         .. code-block:: python
 
-            drawer = MPLDrawer(n_wires=2, n_layers=2)
+            drawer = MPLDrawer(wire_map={0:0, 1:1}, n_layers=2)
 
             drawer.CNOT(0, (0, 1))
 
@@ -778,7 +780,7 @@ class MPLDrawer:
 
         .. code-block:: python
 
-            drawer = MPLDrawer(n_wires=2, n_layers=2)
+            drawer = MPLDrawer(wire_map={0:0, 1:1}, n_layers=2)
 
             drawer.SWAP(0, (0, 1))
 
@@ -848,7 +850,7 @@ class MPLDrawer:
 
         .. code-block:: python
 
-            drawer = MPLDrawer(n_wires=2, n_layers=1)
+            drawer = MPLDrawer(wire_map={0:0, 1:1}, n_layers=1)
             drawer.measure(layer=0, wires=0)
 
             measure_box = {'facecolor': 'white', 'edgecolor': 'indigo'}
@@ -996,7 +998,7 @@ class MPLDrawer:
 
         .. code-block:: python
 
-            drawer = MPLDrawer(n_wires=3, n_layers=4)
+            drawer = MPLDrawer(wire_map={0:0, 1:1, 2:2}, n_layers=4)
 
             drawer.cond(layer=1, measured_layer=0, wires=[0], wires_target=[1])
 
diff --git a/pennylane/drawer/tape_mpl.py b/pennylane/drawer/tape_mpl.py
index b1aa8f93a..a41104e57 100644
--- a/pennylane/drawer/tape_mpl.py
+++ b/pennylane/drawer/tape_mpl.py
@@ -241,7 +241,7 @@ def _tape_mpl(tape, wire_order=None, show_all_wires=False, decimals=None, *, fig
 
     drawer = MPLDrawer(
         n_layers=n_layers,
-        n_wires=n_wires,
+        wire_map=wire_map,
         c_wires=len(bit_map),
         wire_options=wire_options,
         fig=fig,
diff --git a/pennylane/gradients/vjp.py b/pennylane/gradients/vjp.py
index 650624b0c..614406294 100644
--- a/pennylane/gradients/vjp.py
+++ b/pennylane/gradients/vjp.py
@@ -320,7 +320,7 @@ def vjp(tape, dy, gradient_fn, gradient_kwargs=None):
     Executing the VJP tapes, and applying the processing function:
 
     >>> dev = qml.device("default.qubit")
-    >>> vjp = fn(qml.execute(vjp_tapes, dev, gradient_fn=qml.gradients.param_shift, interface="torch"))
+    >>> vjp = fn(qml.execute(vjp_tapes, dev, diff_method=qml.gradients.param_shift, interface="torch"))
     >>> vjp
     tensor([-1.1562e-01, -1.3862e-02, -9.0841e-03, -1.5214e-16, -4.8217e-01,
              2.1329e-17], dtype=torch.float64, grad_fn=<SumBackward1>)
@@ -474,7 +474,7 @@ def batch_vjp(tapes, dys, gradient_fn, reduction="append", gradient_kwargs=None)
     Executing the VJP tapes, and applying the processing function:
 
     >>> dev = qml.device("default.qubit")
-    >>> vjps = fn(qml.execute(vjp_tapes, dev, gradient_fn=qml.gradients.param_shift, interface="torch"))
+    >>> vjps = fn(qml.execute(vjp_tapes, dev, diff_method=qml.gradients.param_shift, interface="torch"))
     >>> vjps
     [tensor([-1.1562e-01, -1.3862e-02, -9.0841e-03, -1.5214e-16, -4.8217e-01,
           2.1329e-17], dtype=torch.float64, grad_fn=<SumBackward1>),
diff --git a/pennylane/io.py b/pennylane/io.py
index c003ab881..d2678727e 100644
--- a/pennylane/io.py
+++ b/pennylane/io.py
@@ -107,7 +107,7 @@ def from_qiskit(quantum_circuit, measurements=None):
         ``measurements=None``.
 
     If an existing ``QuantumCircuit`` already contains measurements, ``from_qiskit``
-    will return those measurements, provided that they are not overriden as shown above.
+    will return those measurements, provided that they are not overridden as shown above.
     These measurements can be used, e.g., for conditioning with
     :func:`qml.cond() <~.cond>`, or simply included directly within the QNode's return:
 
diff --git a/pennylane/labs/dla/cartan_subalgebra.py b/pennylane/labs/dla/cartan_subalgebra.py
index abd6b1e67..e0236595a 100644
--- a/pennylane/labs/dla/cartan_subalgebra.py
+++ b/pennylane/labs/dla/cartan_subalgebra.py
@@ -76,7 +76,7 @@ def cartan_subalgebra(
     A non-unique CSA is a maximal Abelian subalgebra in the horizontal subspace :math:`\mathfrak{m}` of a Cartan decomposition.
     Note that this is sometimes called a horizontal CSA, and is different from the definition of a CSA on `Wikipedia <https://en.wikipedia.org/wiki/Cartan_subalgebra>`__.
 
-    .. seealso:: :func:`~cartan_decomp`, :func:`~structure_constants`, `The KAK theorem (demo) <https://pennylane.ai/qml/demos/tutorial_kak_theorem>`__
+    .. seealso:: :func:`~cartan_decomp`, :func:`~structure_constants`, `The KAK decomposition  theory(demo) <https://pennylane.ai/qml/demos/tutorial_kak_decomposition>`__, `The KAK decomposition in practice (demo) <https://pennylane.ai/qml/demos/tutorial_fixed_depth_hamiltonian_simulation_via_cartan_decomposition>`__.
 
     Args:
         g (List[Union[PauliSentence, np.ndarray]]): Lie algebra :math:`\mathfrak{g}`, which is assumed to be ordered as :math:`\mathfrak{g} = \mathfrak{k} \oplus \mathfrak{m}`
diff --git a/pennylane/labs/dla/variational_kak.py b/pennylane/labs/dla/variational_kak.py
index 04d950f1d..dbcdf886c 100644
--- a/pennylane/labs/dla/variational_kak.py
+++ b/pennylane/labs/dla/variational_kak.py
@@ -82,7 +82,7 @@ def variational_kak_adj(H, g, dims, adj, verbose=False, opt_kwargs=None, pick_mi
     Instead of relying on having Pauli words, we use the adjoint representation
     for a more general evaluation of the cost function. The rest is the same.
 
-    .. seealso:: `Theory demo on KAK theorem <https://pennylane.ai/qml/demos/tutorial_kak_theorem>`__, `demo on KAK decomposition in practice <https://pennylane.ai/qml/demos/tutorial_fixed_depth_hamiltonian_simulation_via_cartan_decomposition>`__,
+    .. seealso:: `The KAK decomposition  theory(demo) <https://pennylane.ai/qml/demos/tutorial_kak_decomposition>`__, `The KAK decomposition in practice (demo) <https://pennylane.ai/qml/demos/tutorial_fixed_depth_hamiltonian_simulation_via_cartan_decomposition>`__.
 
     Args:
         H (Union[Operator, PauliSentence, np.ndarray]): Hamiltonian to decompose
diff --git a/pennylane/measurements/classical_shadow.py b/pennylane/measurements/classical_shadow.py
index 7e9dc5285..d2e249092 100644
--- a/pennylane/measurements/classical_shadow.py
+++ b/pennylane/measurements/classical_shadow.py
@@ -180,8 +180,8 @@ def classical_shadow(wires: WiresLike, seed=None):
             measurements = [qml.classical_shadow(wires=(0,1))]
             tape = qml.tape.QuantumTape(ops, measurements, shots=5)
 
-        >>> bits1, recipes1 = qml.execute([tape], device=dev, gradient_fn=None)[0]
-        >>> bits2, recipes2 = qml.execute([tape], device=dev, gradient_fn=None)[0]
+        >>> bits1, recipes1 = qml.execute([tape], device=dev, diff_method=None)[0]
+        >>> bits2, recipes2 = qml.execute([tape], device=dev, diff_method=None)[0]
         >>> np.all(recipes1 == recipes2)
         True
         >>> np.all(bits1 == bits2)
@@ -200,8 +200,8 @@ def classical_shadow(wires: WiresLike, seed=None):
             measurements2 = [qml.classical_shadow(wires=(0,1), seed=15)]
             tape2 = qml.tape.QuantumTape(ops, measurements2, shots=5)
 
-        >>> bits1, recipes1 = qml.execute([tape1], device=dev, gradient_fn=None)[0]
-        >>> bits2, recipes2 = qml.execute([tape2], device=dev, gradient_fn=None)[0]
+        >>> bits1, recipes1 = qml.execute([tape1], device=dev, diff_method=None)[0]
+        >>> bits2, recipes2 = qml.execute([tape2], device=dev, diff_method=None)[0]
         >>> np.all(recipes1 == recipes2)
         False
         >>> np.all(bits1 == bits2)
diff --git a/pennylane/ops/functions/dot.py b/pennylane/ops/functions/dot.py
index c7cc5b5d2..de4c2f762 100644
--- a/pennylane/ops/functions/dot.py
+++ b/pennylane/ops/functions/dot.py
@@ -52,7 +52,7 @@ def dot(
         method (str): The graph colouring heuristic to use in solving minimum clique cover for
             grouping, which can be ``'lf'`` (Largest First), ``'rlf'`` (Recursive Largest First),
             ``'dsatur'`` (Degree of Saturation), or ``'gis'`` (Greedy Independent Set).
-            This keyword argument is ignored if ``grouping_type`` is ``None``.
+            This keyword argument is ignored if ``grouping_type`` is ``None``. Defaults to ``'lf'`` if no method is provided.
 
     Raises:
         ValueError: if the number of coefficients and operators does not match or if they are empty
diff --git a/pennylane/qchem/molecule.py b/pennylane/qchem/molecule.py
index ed49cd0ac..6aa77a3bd 100644
--- a/pennylane/qchem/molecule.py
+++ b/pennylane/qchem/molecule.py
@@ -62,12 +62,20 @@ class Molecule:
 
     **Example**
 
+    Import necessary modules:
+
+    >>> from pennylane import numpy as np
+    >>> from pennylane.qchem import Molecule
+
+    Define molecular symbols and geometry:
+
     >>> symbols  = ['H', 'H']
     >>> geometry = np.array([[0.0, 0.0, -0.694349],
-    >>>                      [0.0, 0.0,  0.694349]], requires_grad = True)
+    ...                      [0.0, 0.0,  0.694349]], requires_grad = True)
     >>> mol = Molecule(symbols, geometry)
     >>> print(mol.n_electrons)
     2
+
     """
 
     def __init__(
diff --git a/pennylane/qchem/vibrational/taylor_ham.py b/pennylane/qchem/vibrational/taylor_ham.py
index 9f3dbbfc6..a56602464 100644
--- a/pennylane/qchem/vibrational/taylor_ham.py
+++ b/pennylane/qchem/vibrational/taylor_ham.py
@@ -303,19 +303,19 @@ def taylor_coeffs(pes, max_deg=4, min_deg=3):
     >>> pes_twomode = np.zeros((1, 1, 9, 9))
     >>> dipole_onemode = np.zeros((1, 9, 3))
     >>> gauss_weights = np.array([3.96e-05, 4.94e-03, 8.85e-02,
-                                  4.33e-01, 7.20e-01, 4.33e-01,
-                                  8.85e-02, 4.94e-03, 3.96e-05])
+    ...                           4.33e-01, 7.20e-01, 4.33e-01,
+    ...                           8.85e-02, 4.94e-03, 3.96e-05])
     >>> grid = np.array([-3.19, -2.27, -1.47, -0.72,  0.0,  0.72,  1.47,  2.27,  3.19])
     >>> pes_object = qml.qchem.VibrationalPES(
-            freqs=np.array([0.025]),
-            grid=grid,
-            uloc=np.array([[1.0]]),
-            gauss_weights=gauss_weights,
-            pes_data=[pes_onemode, pes_twomode],
-            dipole_data=[dipole_onemode],
-            localized=True,
-            dipole_level=1,
-        )
+    ...     freqs=np.array([0.025]),
+    ...     grid=grid,
+    ...     uloc=np.array([[1.0]]),
+    ...     gauss_weights=gauss_weights,
+    ...     pes_data=[pes_onemode, pes_twomode],
+    ...     dipole_data=[dipole_onemode],
+    ...     localized=True,
+    ...     dipole_level=1,
+    ... )
     >>> one, two = qml.qchem.taylor_coeffs(pes_object, 4, 2)
     >>> print(one)
     [[-0.00088528 -0.00361425  0.00068143]]
@@ -359,22 +359,26 @@ def taylor_dipole_coeffs(pes, max_deg=4, min_deg=1):
     >>> freqs = np.array([0.01885397])
     >>> grid, weights = np.polynomial.hermite.hermgauss(9)
     >>> pes_onebody = np.array([[0.05235573, 0.03093067, 0.01501878, 0.00420778, 0.0,
-                                 0.00584504, 0.02881817, 0.08483433, 0.22025702]])
+    ...                          0.00584504, 0.02881817, 0.08483433, 0.22025702]])
     >>> pes_twobody = None
     >>> dipole_onebody = np.array([[[-1.92201700e-16,  1.45397041e-16, -1.40451549e-01],
-                                    [-1.51005108e-16,  9.53185441e-17, -1.03377032e-01],
-                                    [-1.22793018e-16,  7.22781963e-17, -6.92825934e-02],
-                                    [-1.96537436e-16, -5.86686504e-19, -3.52245369e-02],
-                                    [ 0.00000000e+00,  0.00000000e+00,  0.00000000e+00],
-                                    [ 5.24758835e-17, -1.40650833e-16,  3.69955543e-02],
-                                    [-4.52407941e-17,  1.38406311e-16,  7.60888733e-02],
-                                    [-4.63820104e-16,  5.42928787e-17,  1.17726042e-01],
-                                    [ 1.19224372e-16,  9.12491386e-17,  1.64013197e-01]]])
-    >>>
-    >>> vib_obj = qml.qchem.VibrationalPES(freqs=freqs, grid=grid, gauss_weights=weights,
-                                 uloc = None, pes_data=[pes_onebody, pes_twobody],
-                                 dipole_data=[dipole_onebody], localized=False)
-    >>>
+    ...                             [-1.51005108e-16,  9.53185441e-17, -1.03377032e-01],
+    ...                             [-1.22793018e-16,  7.22781963e-17, -6.92825934e-02],
+    ...                             [-1.96537436e-16, -5.86686504e-19, -3.52245369e-02],
+    ...                             [ 0.00000000e+00,  0.00000000e+00,  0.00000000e+00],
+    ...                             [ 5.24758835e-17, -1.40650833e-16,  3.69955543e-02],
+    ...                             [-4.52407941e-17,  1.38406311e-16,  7.60888733e-02],
+    ...                             [-4.63820104e-16,  5.42928787e-17,  1.17726042e-01],
+    ...                             [ 1.19224372e-16,  9.12491386e-17,  1.64013197e-01]]])
+    >>> vib_obj = qml.qchem.VibrationalPES(
+    ...     freqs=freqs,
+    ...     grid=grid,
+    ...     gauss_weights=weights,
+    ...     uloc=None,
+    ...     pes_data=[pes_onebody, pes_twobody],
+    ...     dipole_data=[dipole_onebody],
+    ...     localized=False
+    ... )
     >>> x, y, z = qml.qchem.taylor_dipole_coeffs(vib_obj, 4, 2)
     >>> print(z)
     [array([[ 1.64124324e-03,  5.39120159e-03, -4.80053702e-05]])]
@@ -657,19 +661,19 @@ def taylor_hamiltonian(
     >>> pes_twomode = np.zeros((1, 1, 9, 9))
     >>> dipole_onemode = np.zeros((1, 9, 3))
     >>> gauss_weights = np.array([3.96e-05, 4.94e-03, 8.85e-02,
-                                  4.33e-01, 7.20e-01, 4.33e-01,
-                                  8.85e-02, 4.94e-03, 3.96e-05])
+    ...                           4.33e-01, 7.20e-01, 4.33e-01,
+    ...                           8.85e-02, 4.94e-03, 3.96e-05])
     >>> grid = np.array([-3.19, -2.27, -1.47, -0.72,  0.0,  0.72,  1.47,  2.27,  3.19])
     >>> pes_object = qml.qchem.VibrationalPES(
-            freqs=np.array([0.025]),
-            grid=grid,
-            uloc=np.array([[1.0]]),
-            gauss_weights=gauss_weights,
-            pes_data=[pes_onemode, pes_twomode],
-            dipole_data=[dipole_onemode],
-            localized=True,
-            dipole_level=1,
-        )
+    ...     freqs=np.array([0.025]),
+    ...     grid=grid,
+    ...     uloc=np.array([[1.0]]),
+    ...     gauss_weights=gauss_weights,
+    ...     pes_data=[pes_onemode, pes_twomode],
+    ...     dipole_data=[dipole_onemode],
+    ...     localized=True,
+    ...     dipole_level=1,
+    ... )
     >>> qml.qchem.taylor_hamiltonian(pes_object, 4, 2)
     (
         -0.003833496032473659 * X(0)
diff --git a/pennylane/qchem/vibrational/vscf.py b/pennylane/qchem/vibrational/vscf.py
index e08e0d155..95dedbcea 100644
--- a/pennylane/qchem/vibrational/vscf.py
+++ b/pennylane/qchem/vibrational/vscf.py
@@ -403,25 +403,25 @@ def vscf_integrals(h_integrals, d_integrals=None, modals=None, cutoff=None, cuto
         tuple: a tuple containing:
             - list[TensorLike[float]]: List of Hamiltonian integrals in VSCF basis for up to 3 coupled vibrational modes.
             - list[TensorLike[float]]: List of dipole integrals in VSCF basis for up to 3 coupled vibrational modes.
-              Returns ``None`` if ``d_integrals`` are ``None``.
+
+        ``None`` is returned if ``d_integrals`` is ``None``.
 
     **Example**
 
     >>> h1 = np.array([[[0.00968289, 0.00233724, 0.0007408,  0.00199125],
-                        [0.00233724, 0.02958449, 0.00675431, 0.0021936],
-                        [0.0007408,  0.00675431, 0.0506012,  0.01280986],
-                        [0.00199125, 0.0021936,  0.01280986, 0.07282307]]])
+    ...                 [0.00233724, 0.02958449, 0.00675431, 0.0021936],
+    ...                 [0.0007408,  0.00675431, 0.0506012,  0.01280986],
+    ...                 [0.00199125, 0.0021936,  0.01280986, 0.07282307]]])
     >>> qml.qchem.vscf_integrals(h_integrals=[h1], modals=[4,4,4])
-    (
-       [array([[[ 9.36124041e-03,  3.63798208e-19, -3.42019607e-19,
-         -3.83743044e-19],
-        [ 9.59982270e-19,  2.77803512e-02,  5.18290259e-18,
-         -4.82000376e-18],
-        [-2.73826508e-19,  4.88583546e-18,  4.63297357e-02,
-         -2.87022759e-18],
-        [-1.94549340e-19, -5.48544743e-18, -1.41379640e-18,
-          7.92203227e-02]]])], None
-    )
+    ([array([[[ 9.36124041e-03, -4.20128342e-19,  3.25260652e-19,
+            1.08420217e-18],
+            [-9.21571847e-19,  2.77803512e-02, -3.46944695e-18,
+            5.63785130e-18],
+            [-3.25260652e-19, -8.67361738e-19,  4.63297357e-02,
+            -1.04083409e-17],
+            [ 1.30104261e-18,  5.20417043e-18, -1.38777878e-17,
+            7.92203227e-02]]])],
+    None)
 
 
     .. details::
diff --git a/pennylane/qcut/cutcircuit.py b/pennylane/qcut/cutcircuit.py
index a0988e3d3..c75b78a7c 100644
--- a/pennylane/qcut/cutcircuit.py
+++ b/pennylane/qcut/cutcircuit.py
@@ -353,7 +353,7 @@ def cut_circuit(
         :func:`~.qcut_processing_fn`, which processes the results to the original full circuit
         output via a tensor network contraction
 
-        >>> results = qml.execute(tapes, dev, gradient_fn=None)
+        >>> results = qml.execute(tapes, dev, diff_method=None)
         >>> qml.qcut.qcut_processing_fn(
         ...     results,
         ...     communication_graph,
diff --git a/pennylane/qcut/cutcircuit_mc.py b/pennylane/qcut/cutcircuit_mc.py
index 7e9e2b0ab..5118cdddc 100644
--- a/pennylane/qcut/cutcircuit_mc.py
+++ b/pennylane/qcut/cutcircuit_mc.py
@@ -355,7 +355,7 @@ def cut_circuit_mc(
         :func:`~.qcut_processing_fn_sample`, which processes the results to approximate the original full circuit
         output bitstrings.
 
-        >>> results = qml.execute(tapes, dev, gradient_fn=None)
+        >>> results = qml.execute(tapes, dev, diff_method=None)
         >>> qml.qcut.qcut_processing_fn_sample(
         ...     results,
         ...     communication_graph,
diff --git a/pennylane/tape/plxpr_conversion.py b/pennylane/tape/plxpr_conversion.py
index 05d98ee64..08254fa5c 100644
--- a/pennylane/tape/plxpr_conversion.py
+++ b/pennylane/tape/plxpr_conversion.py
@@ -60,8 +60,9 @@ class CollectOpsandMeas(PlxprInterpreter):
             return qml.probs(wires=0), qml.expval(qml.Z(1))
 
     >>> from pennylane.tape.plxpr_conversion import CollectOpsandMeas
+    >>> from jax import make_jaxpr
     >>> qml.capture.enable()
-    >>> plxpr = jax.make_plxpr(f)(0.5)
+    >>> plxpr = make_jaxpr(f)(0.5)
     >>> collector = CollectOpsandMeas()
     >>> collector.eval(plxpr.jaxpr, plxpr.consts, 1.2)
     [probs(wires=[0]), expval(Z(1))]
@@ -223,7 +224,7 @@ def plxpr_to_tape(plxpr: "jax.core.Jaxpr", consts, *args, shots=None) -> Quantum
         qml.capture.enable()
 
         plxpr = jax.make_jaxpr(f)(0.5)
-        tape = qml.capture.convert_to_tape(plxpr.jaxpr, plxpr.consts, 1.2)
+        tape = qml.tape.plxpr_to_tape(plxpr.jaxpr, plxpr.consts, 1.2)
         print(qml.drawer.tape_text(tape, decimals=2))
 
     .. code-block::
diff --git a/pennylane/tape/qscript.py b/pennylane/tape/qscript.py
index a0caf54bd..38cdf5ff6 100644
--- a/pennylane/tape/qscript.py
+++ b/pennylane/tape/qscript.py
@@ -141,7 +141,7 @@ class QuantumScript:
     using the :func:`~.pennylane.execute` function:
 
     >>> dev = qml.device('default.qubit', wires=(0,'a'))
-    >>> qml.execute([qscript], dev, gradient_fn=None)
+    >>> qml.execute([qscript], dev, diff_method=None)
     [array([-0.77750694])]
 
     Quantum scripts can also store information about the number and batches of
diff --git a/pennylane/tape/tape.py b/pennylane/tape/tape.py
index 6dff9d644..4d08187b1 100644
--- a/pennylane/tape/tape.py
+++ b/pennylane/tape/tape.py
@@ -419,7 +419,7 @@ class QuantumTape(QuantumScript, AnnotatedQueue):
     >>> tape.num_params
     3
 
-    The existing circuit is overriden upon exiting a recording context.
+    The existing circuit is overridden upon exiting a recording context.
 
     Iterating over the quantum circuit can be done by iterating over the tape
     object:
@@ -448,7 +448,7 @@ class QuantumTape(QuantumScript, AnnotatedQueue):
     device via the :func:`~.pennylane.execute` function:
 
     >>> dev = qml.device("default.qubit", wires=[0, 'a'])
-    >>> qml.execute([tape], dev, gradient_fn=None)
+    >>> qml.execute([tape], dev, diff_method=None)
     [array([0.77750694])]
 
     A new tape can be created by passing new parameters along with the indices
diff --git a/pennylane/templates/embeddings/amplitude.py b/pennylane/templates/embeddings/amplitude.py
index eef3aa462..ea940fdfd 100644
--- a/pennylane/templates/embeddings/amplitude.py
+++ b/pennylane/templates/embeddings/amplitude.py
@@ -62,7 +62,7 @@ class AmplitudeEmbedding(StatePrep):
         The final state of the device is - up to a global phase - equivalent to the input passed to the circuit:
 
         >>> state
-        tensor([0.5+0.j, 0.5+0.j, 0.5+0.j, 0.5+0.j], requires_grad=True)
+        array([0.5+0.j, 0.5+0.j, 0.5+0.j, 0.5+0.j])
 
         **Differentiating with respect to the features**
 
@@ -84,7 +84,7 @@ class AmplitudeEmbedding(StatePrep):
             state = circuit(f=[15, 15, 15, 15])
 
         >>> state
-        tensor([0.5+0.j, 0.5+0.j, 0.5+0.j, 0.5+0.j], requires_grad=True)
+        array([0.5+0.j, 0.5+0.j, 0.5+0.j, 0.5+0.j])
 
         **Padding**
 
@@ -103,7 +103,7 @@ class AmplitudeEmbedding(StatePrep):
             state = circuit(f=[1/sqrt(2), 1/sqrt(2)])
 
         >>> state
-        tensor([0.70710678+0.j, 0.70710678+0.j, 0.        +0.j, 0.        +0.j], requires_grad=True)
+        array([0.70710678+0.j, 0.70710678+0.j, 0.        +0.j, 0.        +0.j])
 
     """
 
diff --git a/pennylane/templates/state_preparations/state_prep_mps.py b/pennylane/templates/state_preparations/state_prep_mps.py
index 36dd85f8d..92fd7edda 100644
--- a/pennylane/templates/state_preparations/state_prep_mps.py
+++ b/pennylane/templates/state_preparations/state_prep_mps.py
@@ -42,22 +42,14 @@ class MPSPrep(Operation):
             np.array([[0.0, 0.107], [0.994, 0.0]]),
             np.array(
                 [
-                    [[0.0, 0.0, 0.0, -0.0], [1.0, 0.0, 0.0, -0.0]],
-                    [[0.0, 1.0, 0.0, -0.0], [0.0, 0.0, 0.0, -0.0]],
-                ]
-            ),
-            np.array(
-                [
-                    [[-1.0, 0.0], [0.0, 0.0]],
-                    [[0.0, 0.0], [0.0, 1.0]],
-                    [[0.0, -1.0], [0.0, 0.0]],
                     [[0.0, 0.0], [1.0, 0.0]],
+                    [[0.0, 1.0], [0.0, 0.0]],
                 ]
             ),
             np.array([[-1.0, -0.0], [-0.0, -1.0]]),
         ]
 
-        dev = qml.device("lightning.tensor", wires = 3)
+        dev = qml.device("lightning.tensor", wires=3)
         @qml.qnode(dev)
         def circuit():
             qml.MPSPrep(mps, wires = [0,1,2])
@@ -66,9 +58,8 @@ class MPSPrep(Operation):
     .. code-block:: pycon
 
         >>> print(circuit())
-        [ 0.    +0.j  0.    +0.j  0.    +0.j -0.1066+0.j  0.    +0.j  0.    +0.j
-          0.    +0.j  0.    +0.j  0.    +0.j  0.    +0.j  0.    +0.j  0.    +0.j
-          0.9943+0.j  0.    +0.j  0.    +0.j  0.    +0.j]
+        [ 0.        +0.j -0.10705513+0.j  0.        +0.j  0.        +0.j
+        0.        +0.j  0.        +0.j -0.99451217+0.j  0.        +0.j]
 
     .. details::
         :title: Usage Details
diff --git a/pennylane/templates/state_preparations/superposition.py b/pennylane/templates/state_preparations/superposition.py
index da6e53d7d..b892fa180 100644
--- a/pennylane/templates/state_preparations/superposition.py
+++ b/pennylane/templates/state_preparations/superposition.py
@@ -140,6 +140,9 @@ class Superposition(Operation):
 
     .. code-block::
 
+        import pennylane as qml
+        import numpy as np
+
         coeffs = np.sqrt(np.array([1/3, 1/3, 1/3]))
         bases = np.array([[1, 1, 1], [0, 1, 0], [0, 0, 0]])
         wires = [0, 1, 2]
@@ -265,7 +268,7 @@ class Superposition(Operation):
         )
 
     @staticmethod
-    def compute_decomposition(coefs, bases, wires, work_wire):  # pylint: disable=arguments-differ
+    def compute_decomposition(coeffs, bases, wires, work_wire):  # pylint: disable=arguments-differ
         r"""Representation of the operator as a product of other operators.
 
         Args:
@@ -289,7 +292,7 @@ class Superposition(Operation):
 
         """
 
-        dic_state = dict(zip(bases, coefs))
+        dic_state = dict(zip(bases, coeffs))
         perms = _assign_states(bases)
         new_dic_state = {perms[key]: dic_state[key] for key in dic_state if key in perms}
 
@@ -304,7 +307,7 @@ class Superposition(Operation):
         op_list.append(
             qml.StatePrep(
                 qml.math.stack(sorted_coefficients),
-                wires=wires[-int(qml.math.ceil(qml.math.log2(len(coefs)))) :],
+                wires=wires[-int(qml.math.ceil(qml.math.log2(len(coeffs)))) :],
                 pad_with=0,
             )
         )
diff --git a/pennylane/templates/subroutines/adder.py b/pennylane/templates/subroutines/adder.py
index ade18bdad..2ad462abf 100644
--- a/pennylane/templates/subroutines/adder.py
+++ b/pennylane/templates/subroutines/adder.py
@@ -47,7 +47,7 @@ class Adder(Operation):
         mod (int): the modulo for performing the addition. If not provided, it will be set to its maximum value, :math:`2^{\text{len(x_wires)}}`.
         work_wires (Sequence[int]): the auxiliary wires to use for the addition. The
             work wires are not needed if :math:`mod=2^{\text{len(x_wires)}}`, otherwise two work wires
-            should be provided. Defaults to empty set.
+            should be provided. Defaults to empty tuple.
 
     **Example**
 
diff --git a/pennylane/templates/subroutines/gqsp.py b/pennylane/templates/subroutines/gqsp.py
index c980b19b4..d676391ad 100644
--- a/pennylane/templates/subroutines/gqsp.py
+++ b/pennylane/templates/subroutines/gqsp.py
@@ -39,7 +39,7 @@ class GQSP(Operation):
          * & * \\
          \end{pmatrix}
 
-    The implementation requires one auxiliary qubit.
+    The implementation requires one control qubit.
 
     Args:
 
diff --git a/pennylane/templates/subroutines/mod_exp.py b/pennylane/templates/subroutines/mod_exp.py
index 103e22a91..467ca7396 100644
--- a/pennylane/templates/subroutines/mod_exp.py
+++ b/pennylane/templates/subroutines/mod_exp.py
@@ -50,7 +50,7 @@ class ModExp(Operation):
         mod (int): the modulo for performing the exponentiation. If not provided, it will be set to its maximum value, :math:`2^{\text{len(output_wires)}}`
         work_wires (Sequence[int]): the auxiliary wires to use for the exponentiation. If
             :math:`mod=2^{\text{len(output_wires)}}`, the number of auxiliary wires must be ``len(output_wires)``. Otherwise
-            ``len(output_wires) + 2`` auxiliary wires are needed. Defaults to empty set.
+            ``len(output_wires) + 2`` auxiliary wires are needed. Defaults to empty tuple.
 
     **Example**
 
diff --git a/pennylane/templates/subroutines/out_adder.py b/pennylane/templates/subroutines/out_adder.py
index edf091572..d8ead9c51 100644
--- a/pennylane/templates/subroutines/out_adder.py
+++ b/pennylane/templates/subroutines/out_adder.py
@@ -44,7 +44,7 @@ class OutAdder(Operation):
         y_wires (Sequence[int]): the wires that store the integer :math:`y`
         output_wires (Sequence[int]): the wires that store the addition result. If the register is in a non-zero state :math:`b`, the solution will be added to this value.
         mod (int): the modulo for performing the addition. If not provided, it will be set to its maximum value, :math:`2^{\text{len(output_wires)}}`.
-        work_wires (Sequence[int]): the auxiliary wires to use for the addition. The work wires are not needed if :math:`mod=2^{\text{len(output_wires)}}`, otherwise two work wires should be provided. Defaults to empty set.
+        work_wires (Sequence[int]): the auxiliary wires to use for the addition. The work wires are not needed if :math:`mod=2^{\text{len(output_wires)}}`, otherwise two work wires should be provided. Defaults to empty tuple.
 
     **Example**
 
diff --git a/pennylane/templates/subroutines/out_multiplier.py b/pennylane/templates/subroutines/out_multiplier.py
index 58ecc1c61..c58428825 100644
--- a/pennylane/templates/subroutines/out_multiplier.py
+++ b/pennylane/templates/subroutines/out_multiplier.py
@@ -45,7 +45,7 @@ class OutMultiplier(Operation):
         mod (int): the modulo for performing the multiplication. If not provided, it will be set to its maximum value, :math:`2^{\text{len(output_wires)}}`
         work_wires (Sequence[int]): the auxiliary wires to use for the multiplication. The
             work wires are not needed if :math:`mod=2^{\text{len(output_wires)}}`, otherwise two work wires
-            should be provided. Defaults to empty set.
+            should be provided. Defaults to empty tuple.
 
     **Example**
 
diff --git a/pennylane/templates/subroutines/out_poly.py b/pennylane/templates/subroutines/out_poly.py
index 4472bfb49..f54947ce8 100644
--- a/pennylane/templates/subroutines/out_poly.py
+++ b/pennylane/templates/subroutines/out_poly.py
@@ -152,14 +152,15 @@ class OutPoly(Operation):
     Args:
 
         polynomial_function (callable): The polynomial function to be applied. The number of arguments in the function
-                                        must be equal to the number of input registers.
-        input_registers (List[Union[Wires, Sequence[int]]]): List containing the wires (or the wire indices) used to store each variable of the polynomial.
+            must be equal to the number of input registers.
+        input_registers (List[Union[Wires, Sequence[int]]]): List containing the wires (or the wire indices) used to
+            store each variable of the polynomial.
         output_wires (Union[Wires, Sequence[int]]): The wires (or wire indices) used to store the output of the operation.
-        mod (int, optional): The integer for performing the modulo on the result of the polynomial operation. If not provided, it defaults
-                             to :math:`2^{n}`, where :math:`n` is the number of qubits in the output register.
-        work_wires (Union[Wires, Sequence[int]], optional): The auxiliary wires to use for performing the polynomial operation. The
-                    work wires are not needed if :math:`mod=2^{\text{length(output_wires)}}`, otherwise two work wires
-                    should be provided. Default is empty set.
+        mod (int, optional): The integer for performing the modulo on the result of the polynomial operation. If not provided,
+            it defaults to :math:`2^{n}`, where :math:`n` is the number of qubits in the output register.
+        work_wires (Union[Wires, Sequence[int]], optional): The auxiliary wires to use for performing the polynomial operation.
+            The work wires are not needed if :math:`mod=2^{\text{length(output_wires)}}`, otherwise two work wires should be
+            provided. Defaults to empty tuple.
 
     Raises:
         ValueError: If `mod` is not :math:`2^{\text{length(output_wires)}}` and insufficient number of work wires are provided.
diff --git a/pennylane/templates/subroutines/phase_adder.py b/pennylane/templates/subroutines/phase_adder.py
index 9460f0e3f..4c4ffa433 100644
--- a/pennylane/templates/subroutines/phase_adder.py
+++ b/pennylane/templates/subroutines/phase_adder.py
@@ -65,7 +65,7 @@ class PhaseAdder(Operation):
             value for `mod`.
         mod (int): the modulo for performing the addition. If not provided, it will be set to its maximum value, :math:`2^{\text{len(x_wires)}}`.
         work_wire (Sequence[int] or int): the auxiliary wire to use for the addition. Optional
-            when `mod` is :math:`2^{len(x\_wires)}`. Defaults to empty set.
+            when `mod` is :math:`2^{len(x\_wires)}`. Defaults to empty tuple.
 
     **Example**
 
diff --git a/pennylane/templates/subroutines/qsvt.py b/pennylane/templates/subroutines/qsvt.py
index 03f141127..129e6d930 100644
--- a/pennylane/templates/subroutines/qsvt.py
+++ b/pennylane/templates/subroutines/qsvt.py
@@ -17,6 +17,7 @@ Contains the QSVT template and qsvt wrapper function.
 # pylint: disable=too-many-arguments
 import copy
 import warnings
+from typing import Literal
 
 import numpy as np
 from numpy.polynomial import Polynomial, chebyshev
@@ -215,6 +216,8 @@ def qsvt(A, poly, encoding_wires=None, block_encoding=None, **kwargs):
         (Operator): A quantum operator implementing QSVT on the matrix ``A`` with the
         specified encoding and projector phases.
 
+    .. seealso:: :class:`~.QSVT`
+
     Example:
 
     .. code-block:: python
@@ -326,7 +329,7 @@ def qsvt(A, poly, encoding_wires=None, block_encoding=None, **kwargs):
 
     """
 
-    if encoding_wires is None or block_encoding is None or "wires" in kwargs.keys():
+    if encoding_wires is None or block_encoding is None or "wires" in kwargs:
         warnings.warn(
             "You may be trying to use the old `qsvt` functionality (now `qml.qsvt_legacy`).\n"
             "Make sure you pass a polynomial instead of angles.\n"
@@ -1035,7 +1038,7 @@ def transform_angles(angles, routine1, routine2):
     )
 
 
-def poly_to_angles(poly, routine, angle_solver="root-finding"):
+def poly_to_angles(poly, routine, angle_solver: Literal["root-finding"] = "root-finding"):
     r"""
     Computes the angles needed to implement a polynomial transformation with quantum signal processing (QSP)
     or quantum singular value transformation (QSVT).
@@ -1050,6 +1053,7 @@ def poly_to_angles(poly, routine, angle_solver="root-finding"):
         routine (str): the routine for which the angles are computed. Must be either ``"QSP"`` or ``"QSVT"``.
 
         angle_solver (str): the method used to calculate the angles. Default is ``"root-finding"``.
+            ``"root-finding"`` is currently the only supported method.
 
     Returns:
         (tensor-like): computed angles for the specified routine
diff --git a/pennylane/transforms/core/transform_program.py b/pennylane/transforms/core/transform_program.py
index b4a132b4a..fa74b78e0 100644
--- a/pennylane/transforms/core/transform_program.py
+++ b/pennylane/transforms/core/transform_program.py
@@ -237,6 +237,8 @@ class TransformProgram:
 
     Programs have several implemented dunder methods for easy manipulation.
 
+    >>> from pennylane.transforms.core.transform_program import TransformProgram
+    >>> from copy import copy
     >>> program = TransformProgram()
     >>> program.add_transform(qml.compile)
     >>> program.add_transform(qml.transforms.cancel_inverses)
@@ -252,7 +254,7 @@ class TransformProgram:
     True
     >>> True if TransformProgram() else False
     False
-    >>> program2 = copy.copy(program)
+    >>> program2 = copy(program)
     >>> program2 == program
     True
     >>> qml.compile in program
diff --git a/pennylane/transforms/diagonalize_measurements.py b/pennylane/transforms/diagonalize_measurements.py
index bad7a9fd0..797297484 100644
--- a/pennylane/transforms/diagonalize_measurements.py
+++ b/pennylane/transforms/diagonalize_measurements.py
@@ -90,19 +90,19 @@ def diagonalize_measurements(tape, supported_base_obs=_default_supported_obs, to
     measurements to be in the Z basis, so the original circuit
 
     >>> print(qml.draw(circuit, level=0)([np.pi/4, np.pi/4]))
-    0: ──RY(0.79)─┤ ╭<X@Z> ╭Var[(0.50*Y)+X]
+    0: ──RY(0.79)─┤ ╭<X@Z> ╭Var[𝓗(0.50)]
     1: ──RX(0.79)─┤ ╰<X@Z> │
-    2: ───────────┤        ╰Var[(0.50*Y)+X]
+    2: ───────────┤        ╰Var[𝓗(0.50)]
 
     becomes
 
     >>> print(qml.draw(circuit)([np.pi/4, np.pi/4]))
-    0: ──RY(0.79)──H────┤ ╭<Z@Z> ╭Var[(0.50*Z)+Z]
+    0: ──RY(0.79)──H────┤ ╭<Z@Z> ╭Var[𝓗(0.50)]
     1: ──RX(0.79)───────┤ ╰<Z@Z> │
-    2: ──Z─────────S──H─┤        ╰Var[(0.50*Z)+Z]
+    2: ──Z─────────S──H─┤        ╰Var[𝓗(0.50)]
 
     >>> circuit([np.pi/4, np.pi/4])
-    (tensor(0.5, requires_grad=True), tensor(0.75, requires_grad=True))
+    (0.5, 0.75)
 
     .. details::
         :title: Usage Details
@@ -116,7 +116,7 @@ def diagonalize_measurements(tape, supported_base_obs=_default_supported_obs, to
                 qml.expval(qml.X(0) + qml.Hermitian([[1, 0], [0, 1]], wires=[1]))
             ]
             tape = qml.tape.QuantumScript(measurements=measurements)
-            tapes, processsing_fn = diagnalize_measurements(tape)
+            tapes, processsing_fn = diagonalize_measurements(tape)
 
         >>> tapes[0].operations
         [H(0)]
diff --git a/pennylane/workflow/_capture_qnode.py b/pennylane/workflow/_capture_qnode.py
index 41b8b37e1..940d8eddd 100644
--- a/pennylane/workflow/_capture_qnode.py
+++ b/pennylane/workflow/_capture_qnode.py
@@ -27,12 +27,12 @@ associated with a circuit. Dynamically mutating objects is not compatible with j
 and reshape the outputs from measurements on the device when multiple measurements are present.
 
 **Gradients other than default qubit backprop**. We managed to get backprop of default qubit for
-free, but no other gradients methods have support yet.
+free, but no other gradient methods have support yet.
 
-**MCM methods other than single branch statistics**. Mid circuit measurements
+**MCM methods other than single branch statistics**. Mid-circuit measurements
 are only handled via a "single branch statistics" algorithm, which will lead to unexpected
 results. Even on analytic devices, one branch will be randomly chosen on each execution.
-Returning measurements based on mid circuit measurements, ``qml.sample(m0)``,
+Returning measurements based on mid-circuit measurements, ``qml.sample(m0)``,
 is also not yet supported on default qubit or lightning.
 
 >>> @qml.qnode(qml.device('default.qubit', wires=1))
@@ -76,8 +76,8 @@ TypeError: RX(): incompatible function arguments. The following argument types a
     2. (self: pennylane_lightning.lightning_qubit_ops.StateVectorC128, arg0: list[int], arg1: list[bool], arg2: list[int], arg3: bool, arg4: list[float]) -> None
 
 **Grouping commuting measurements and/or splitting up non-commuting measurements.** Currently, each
-measurment is fully independent and generated from different raw samples than every other measurement.
-To generate multiple measurments from the same samples, we need a way of denoting which measurements
+measurement is fully independent and generated from different raw samples than every other measurement.
+To generate multiple measurement from the same samples, we need a way of denoting which measurements
 should be taken together. A "Combination measurement process" higher order primitive, or something like it.
 We will also need to figure out how to implement splitting up a circuit with non-commuting measurements into
 multiple circuits.
diff --git a/pennylane/workflow/execution.py b/pennylane/workflow/execution.py
index 4a84b4724..7c9fb93b0 100644
--- a/pennylane/workflow/execution.py
+++ b/pennylane/workflow/execution.py
@@ -68,27 +68,27 @@ def execute(
             for the gradient (if supported).
         interface (str, Interface): The interface that will be used for classical auto-differentiation.
             This affects the types of parameters that can exist on the input tapes.
-            Available options include ``autograd``, ``torch``, ``tf``, ``jax`` and ``auto``.
+            Available options include ``autograd``, ``torch``, ``tf``, ``jax``, and ``auto``.
         transform_program(.TransformProgram): A transform program to be applied to the initial tape.
         inner_transform (.TransformProgram): A transform program to be applied to the tapes in
             inner execution, inside the ml interface.
         config (qml.devices.ExecutionConfig): A data structure describing the parameters
             needed to fully describe the execution.
         grad_on_execution (bool, str): Whether the gradients should be computed
-            on the execution or not. Only applies
+            on the execution or not. It only applies
             if the device is queried for the gradient; gradient transform
             functions available in ``qml.gradients`` are only supported on the backward
             pass. The 'best' option chooses automatically between the two options and is default.
         gradient_kwargs (dict): dictionary of keyword arguments to pass when
-            determining the gradients of tapes
+            determining the gradients of tapes.
         cache (None, bool, dict, Cache): Whether to cache evaluations. This can result in
             a significant reduction in quantum evaluations during gradient computations.
-        cachesize (int): the size of the cache
+        cachesize (int): the size of the cache.
         max_diff (int): If ``gradient_fn`` is a gradient transform, this option specifies
             the maximum number of derivatives to support. Increasing this value allows
-            for higher order derivatives to be extracted, at the cost of additional
-            (classical) computational overhead during the backwards pass.
-        device_vjp=False (Optional[bool]): whether or not to use the device provided jacobian
+            for higher-order derivatives to be extracted, at the cost of additional
+            (classical) computational overhead during the backward pass.
+        device_vjp=False (Optional[bool]): whether or not to use the device-provided Jacobian
             product if it is available.
         mcm_config (dict): Dictionary containing configuration options for handling
             mid-circuit measurements.
diff --git a/pennylane/workflow/qnode.py b/pennylane/workflow/qnode.py
index 53e50d21e..14f4f6fc9 100644
--- a/pennylane/workflow/qnode.py
+++ b/pennylane/workflow/qnode.py
@@ -364,11 +364,7 @@ class QNode:
         to support it.) A list of supporting operators is available in
         :obj:`~.pennylane.ops.qubit.attributes.supports_broadcasting`.
         Whether or not broadcasting delivers an increased performance will depend on whether the
-        used device is a classical simulator and natively supports this. The latter can be checked
-        with the capabilities of the device:
-
-        >>> dev.capabilities()["supports_broadcasting"]
-        True
+        used device is a classical simulator and natively supports this.
 
         If a device does not natively support broadcasting, it will execute broadcasted QNode calls
         by expanding the input arguments into separate executions. That is, every device can
diff --git a/pennylane/workflow/return_types_spec.rst b/pennylane/workflow/return_types_spec.rst
index 90233e8be..38597c914 100644
--- a/pennylane/workflow/return_types_spec.rst
+++ b/pennylane/workflow/return_types_spec.rst
@@ -53,7 +53,7 @@ array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 Empty Wires
 ^^^^^^^^^^^
 
-Some measurments allow broadcasting over all available wires, like ``qml.probs()``, ``qml.sample()``,
+Some measurements allow broadcasting over all available wires, like ``qml.probs()``, ``qml.sample()``,
 or ``qml.state()``. In such a case, the measurement process instance should have empty wires.
 The shape of the result object may be dictated either by the device or the other operations present in the circuit.
 


Test patch:
diff --git a/tests/capture/autograph/test_autograph.py b/tests/capture/autograph/test_autograph.py
index 1665eb3fe..5ec9e7fa5 100644
--- a/tests/capture/autograph/test_autograph.py
+++ b/tests/capture/autograph/test_autograph.py
@@ -270,7 +270,7 @@ class TestIntegration:
         assert jax.core.eval_jaxpr(plxpr.jaxpr, plxpr.consts)[0] == -1
 
     def test_ctrl_op(self):
-        """Test that the adjoint of an operator successfully passes through autograph without raising an error"""
+        """Test that controlled operators successfully pass through autograph"""
 
         @qml.qnode(qml.device("default.qubit", wires=2))
         def circ():
diff --git a/tests/capture/test_base_interpreter.py b/tests/capture/test_base_interpreter.py
index e02d1d391..a453005d9 100644
--- a/tests/capture/test_base_interpreter.py
+++ b/tests/capture/test_base_interpreter.py
@@ -188,7 +188,7 @@ def test_default_measurement_handling():
 
 
 def test_measurement_handling():
-    """Test that the default measurment handling works."""
+    """Test that the default measurement handling works."""
 
     @SimplifyInterpreter()
     def f(w):
diff --git a/tests/devices/qubit_mixed/conftest.py b/tests/devices/qubit_mixed/conftest.py
index 1997eb161..5f412ebc9 100644
--- a/tests/devices/qubit_mixed/conftest.py
+++ b/tests/devices/qubit_mixed/conftest.py
@@ -17,7 +17,7 @@ import pytest
 from scipy.stats import unitary_group
 
 
-def get_random_mixed_state(num_qubits):
+def get_random_mixed_state(num_qubits: int) -> np.ndarray:
     """
     Generates a random mixed state for testing purposes.
 
diff --git a/tests/drawer/test_draw_mpl.py b/tests/drawer/test_draw_mpl.py
index 23ca78d19..c8c162cce 100644
--- a/tests/drawer/test_draw_mpl.py
+++ b/tests/drawer/test_draw_mpl.py
@@ -319,7 +319,7 @@ class TestWireBehaviour:
         assert ax.texts[2].get_text() == "0"
         plt.close()
 
-    def test_wire_options(self):
+    def test_uniform_wire_options(self):
         """Test wire options modifies wire styling"""
 
         _, ax = qml.draw_mpl(circuit1, wire_options={"color": "black", "linewidth": 4})(1.23, 2.34)
@@ -328,6 +328,11 @@ class TestWireBehaviour:
             assert w.get_color() == "black"
             assert w.get_linewidth() == 4
 
+        plt.close()
+
+    def test_individual_wire_options(self):
+        """Test wire option styling when individual wires have their own options specified"""
+
         @qml.qnode(dev)
         def f_circ(x):
             """Circuit on ten qubits."""
@@ -399,6 +404,58 @@ class TestWireBehaviour:
 
         plt.close()
 
+    def test_individual_wire_options_with_string_labels(self):
+        """Test that individual wire options work with string wire labels"""
+
+        @qml.qnode(qml.device("default.qubit"))
+        def circuit():
+            qml.X("a")
+            qml.Y("b")
+            return qml.expval(qml.Z("a"))
+
+        wire_options = {
+            "color": "teal",
+            "linewidth": 5,
+            "b": {"color": "orange", "linestyle": "--"},
+        }
+        _, ax = qml.draw_mpl(circuit, wire_options=wire_options)()
+
+        for i, w in enumerate(ax.lines):
+            assert w.get_linewidth() == 5
+            if i == 0:
+                assert w.get_color() == "teal"
+                assert w.get_linestyle() == "-"
+            if i == 1:
+                assert w.get_color() == "orange"
+                assert w.get_linestyle() == "--"
+
+    def test_wire_options_and_wire_order(self):
+        """Test that individual wire options work with specifying a wire_order"""
+
+        device = qml.device("default.qubit", wires=4)
+
+        @qml.qnode(device)
+        def circuit():
+            for w in device.wires:
+                qml.X(w)
+            return qml.expval(qml.Z(0))
+
+        wire_options = {
+            "color": "teal",
+            "linewidth": 5,
+            3: {"color": "orange", "linestyle": "--"},  # wire 3 should be orange and dashed
+        }
+        _, ax = qml.draw_mpl(circuit, wire_order=[1, 3, 0, 2], wire_options=wire_options)()
+
+        for i, w in enumerate(ax.lines):
+            assert w.get_linewidth() == 5
+            if i == 1:
+                assert w.get_color() == "orange"
+                assert w.get_linestyle() == "--"
+            else:
+                assert w.get_color() == "teal"
+                assert w.get_linestyle() == "-"
+
 
 class TestMPLIntegration:
     """Test using matplotlib styling to modify look of graphic."""
diff --git a/tests/drawer/test_drawer_utils.py b/tests/drawer/test_drawer_utils.py
index 6ef4c2f6e..ba4b35c1c 100644
--- a/tests/drawer/test_drawer_utils.py
+++ b/tests/drawer/test_drawer_utils.py
@@ -220,7 +220,7 @@ class TestCwireConnections:
         assert wires == [[0, 0]]
 
     def test_multiple_measure_multiple_cond(self):
-        """Test a case with multiple measurments and multiple conditionals."""
+        """Test a case with multiple measurements and multiple conditionals."""
         m0 = qml.measure(0)
         m1 = qml.measure(1)
         m2_nonused = qml.measure(2)
diff --git a/tests/drawer/test_mpldrawer.py b/tests/drawer/test_mpldrawer.py
index b28e6070b..1dd5f00a2 100644
--- a/tests/drawer/test_mpldrawer.py
+++ b/tests/drawer/test_mpldrawer.py
@@ -35,17 +35,19 @@ from pennylane.math import allclose
 class TestInitialization:
     """Tests drawer creation"""
 
-    @pytest.mark.parametrize("n_wires", [2, 3])
+    @pytest.mark.parametrize("wire_map", [{0: 0, 1: 1}, {"a": 0, "b": 1, "c": 2}])
     @pytest.mark.parametrize("n_layers", [2, 3])
-    def test_figsize_wires(self, n_wires, n_layers):
+    def test_figsize_wires(self, wire_map, n_layers):
         """Tests the figure is sized correctly."""
 
-        drawer = MPLDrawer(n_wires=n_wires, n_layers=n_layers)
+        n_wires = len(wire_map)
+
+        drawer = MPLDrawer(wire_map=wire_map, n_layers=n_layers)
 
         assert drawer.fig.get_figwidth() == (n_layers + 3)
         assert drawer.fig.get_figheight() == (n_wires + 1)
 
-        drawer = MPLDrawer(n_wires=n_wires, n_layers=n_layers)
+        drawer = MPLDrawer(wire_map=wire_map, n_layers=n_layers)
 
         lines = drawer.ax.lines
 
@@ -62,7 +64,9 @@ class TestInitialization:
         c_wires = 4
         n_layers = 1
 
-        drawer = MPLDrawer(n_wires=n_wires, n_layers=n_layers, c_wires=c_wires)
+        drawer = MPLDrawer(
+            wire_map={i: i for i in range(n_wires)}, n_layers=n_layers, c_wires=c_wires
+        )
 
         assert drawer.fig.get_figheight() == n_wires + 1 + 0.25 * 4 + 0.5
         assert drawer.fig.get_figwidth() == n_layers + 3
@@ -73,7 +77,7 @@ class TestInitialization:
     def test_customfigsize(self):
         """Tests a custom figsize alters the size"""
 
-        drawer = MPLDrawer(1, 1, figsize=(5, 5))
+        drawer = MPLDrawer(1, {0: 0}, figsize=(5, 5))
 
         assert drawer.fig.get_figwidth() == 5
         assert drawer.fig.get_figheight() == 5
@@ -83,7 +87,7 @@ class TestInitialization:
         """Tests a custom figure is used"""
 
         fig = plt.figure()
-        drawer = MPLDrawer(1, 1, fig=fig)
+        drawer = MPLDrawer(1, {0: 0}, fig=fig)
 
         assert drawer.fig == fig
         plt.close()
@@ -91,7 +95,7 @@ class TestInitialization:
     def test_config_params_set(self):
         """Tests sizing hidden variables are set."""
 
-        drawer = MPLDrawer(1, 1)
+        drawer = MPLDrawer(1, {0: 0})
 
         assert drawer._box_length == 0.75
         assert drawer._circ_rad == 0.3
@@ -111,7 +115,7 @@ class TestInitialization:
 
         rgba_red = (1, 0, 0, 1)
         options = {"linewidth": 3, "color": rgba_red}
-        drawer = MPLDrawer(n_wires=2, n_layers=2, wire_options=options)
+        drawer = MPLDrawer(wire_map={0: 0, 1: 1}, n_layers=2, wire_options=options)
 
         for line in drawer.ax.lines:
             assert line.get_linewidth() == 3
@@ -121,7 +125,7 @@ class TestInitialization:
 
     def test_fontsize(self):
         """Test fontsize can be get and set via property."""
-        drawer = MPLDrawer(1, 1)
+        drawer = MPLDrawer(1, {0: 0})
 
         assert drawer._fontsize == drawer.fontsize
         assert drawer.fontsize == 14
@@ -139,9 +143,11 @@ class TestLabels:
     def test_labels(self):
         """Tests labels are added"""
 
-        drawer = MPLDrawer(1, 3)
+        wire_map = {"a": 0, "b": 1, "c": 2}
+
+        drawer = MPLDrawer(1, wire_map)
 
-        labels = ("a", "b", "c")
+        labels = wire_map.keys()
         drawer.label(labels)
 
         drawn_labels = drawer.ax.texts
@@ -156,10 +162,12 @@ class TestLabels:
     def test_labels_formatting(self):
         """Test labels are formatted with text options."""
 
-        drawer = MPLDrawer(1, 3)
+        wire_map = {0: 0, 1: 1, 2: 2}
+
+        drawer = MPLDrawer(1, wire_map)
 
         rgba_red = (1, 0, 0, 1)
-        labels = (0, 1, 2)
+        labels = wire_map.keys()
         options = {"fontsize": 10, "color": rgba_red}
         drawer.label(labels, text_options=options)
 
@@ -172,9 +180,12 @@ class TestLabels:
     @pytest.mark.parametrize("n_layers", [1, 4])
     def test_crop_wire_labels(self, n_layers):
         """Test that cropping wire labels works."""
-        drawer = MPLDrawer(n_layers, 3)
 
-        labels = ("a", "b", "c")
+        wire_map = {"a": 0, "b": 1, "c": 2}
+
+        drawer = MPLDrawer(n_layers, wire_map)
+
+        labels = wire_map.keys()
         drawer.label(labels)
         old_width = drawer.fig.get_figwidth()
         assert old_width == n_layers + 3
@@ -190,7 +201,7 @@ class TestLabels:
 def test_erase_wire():
     """Test the erase wire method."""
 
-    drawer = MPLDrawer(5, 1)
+    drawer = MPLDrawer(5, {0: 0})
     drawer.erase_wire(1, 0, 3)
 
     assert len(drawer.ax.patches) == 1
@@ -208,7 +219,7 @@ class TestBoxGate:
     def test_simple_box(self):
         """tests basic functionality of box_gate."""
 
-        drawer = MPLDrawer(1, 1)
+        drawer = MPLDrawer(1, {0: 0})
 
         drawer.box_gate(0, 0, "X")
 
@@ -230,7 +241,7 @@ class TestBoxGate:
     def test_multiwire_box(self):
         """tests a gate spanning multiple wires."""
 
-        drawer = MPLDrawer(1, 3)
+        drawer = MPLDrawer(1, {0: 0, 1: 1, 2: 2})
         drawer.box_gate(0, (0, 2), text="Tall Gate")
 
         box = drawer.ax.patches[0]
@@ -251,7 +262,7 @@ class TestBoxGate:
     def test_notch_standard_styling(self):
         """Test notch styling is correct"""
 
-        drawer = MPLDrawer(n_layers=1, n_wires=3)
+        drawer = MPLDrawer(n_layers=1, wire_map={i: i for i in range(3)})
         drawer.box_gate(0, (0, 2))
 
         xs = [-0.415, 0.375, -0.415, 0.375]
@@ -273,7 +284,7 @@ class TestBoxGate:
     def test_active_wire_notches_number(self, wires, n_notches):
         """Tests the number of active wires drawn is the expected amount."""
 
-        drawer = MPLDrawer(n_layers=1, n_wires=4)
+        drawer = MPLDrawer(n_layers=1, wire_map={i: i for i in range(4)})
         drawer.box_gate(layer=0, wires=wires)
 
         assert len(drawer.ax.patches) == (n_notches + 1)
@@ -281,7 +292,7 @@ class TestBoxGate:
 
     def test_no_active_wire_notches(self):
         """Test active wire notches deactivated by keyword."""
-        drawer = MPLDrawer(n_layers=1, n_wires=3)
+        drawer = MPLDrawer(n_layers=1, wire_map={i: i for i in range(3)})
         drawer.box_gate(layer=0, wires=(0, 2), active_wire_notches=False)
 
         # only one patch for big box, no patches for notches
@@ -291,7 +302,7 @@ class TestBoxGate:
     def test_extra_width(self):
         """tests a box with added width."""
 
-        drawer = MPLDrawer(1, 3)
+        drawer = MPLDrawer(1, {i: i for i in range(3)})
         drawer.box_gate(0, (0, 2), text="Wide Gate", extra_width=0.4)
 
         box = drawer.ax.patches[0]
@@ -315,7 +326,7 @@ class TestBoxGate:
     def test_box_formatting(self):
         """Tests that box_options influences the rectangle"""
 
-        drawer = MPLDrawer(1, 3)
+        drawer = MPLDrawer(1, {i: i for i in range(3)})
         rgba_red = (1, 0, 0, 1)
         rgba_green = (0, 1, 0, 1)
         options = {"facecolor": rgba_red, "edgecolor": rgba_green, "zorder": 5}
@@ -335,7 +346,7 @@ class TestBoxGate:
     def test_text_formatting(self):
         """Tests rotated text"""
 
-        drawer = MPLDrawer(1, 1)
+        drawer = MPLDrawer(1, {0: 0})
         rgba_red = (1, 0, 0, 1)
         options = {"color": rgba_red, "rotation": "vertical"}
         drawer.box_gate(0, 0, text="X", text_options=options)
@@ -352,7 +363,7 @@ class TestCTRL:
     def test_ctrl_no_target(self):
         """Tests a single control with no target"""
 
-        drawer = MPLDrawer(1, 1)
+        drawer = MPLDrawer(1, {0: 0})
 
         drawer.ctrl(0, 0)
 
@@ -371,7 +382,7 @@ class TestCTRL:
     def test_ctrl_multi_wires(self):
         """Tests two control wires with no target."""
 
-        drawer = MPLDrawer(1, 3)
+        drawer = MPLDrawer(1, {i: i for i in range(3)})
 
         ctrl_wires = (0, 1)
         drawer.ctrl(0, ctrl_wires)
@@ -392,7 +403,7 @@ class TestCTRL:
     def test_ctrl_on_zero(self):
         """Tests a control on zero circle is open"""
 
-        drawer = MPLDrawer(1, 1)
+        drawer = MPLDrawer(1, {0: 0})
 
         drawer.ctrl(0, 0, control_values=False)
 
@@ -409,7 +420,7 @@ class TestCTRL:
     def test_ctrl_control_values_error(self):
         """Tests a ValueError is raised if different number of wires and control_values."""
 
-        drawer = MPLDrawer(1, 2)
+        drawer = MPLDrawer(1, {0: 0, 1: 1})
 
         with pytest.raises(ValueError, match="`control_values` must be the same length"):
             drawer.ctrl(0, (0, 1), control_values=True)
@@ -419,7 +430,7 @@ class TestCTRL:
     def test_ctrl_formatting(self):
         """Tests two control wires with no target."""
 
-        drawer = MPLDrawer(1, 3)
+        drawer = MPLDrawer(1, {i: i for i in range(3)})
 
         ctrl_wires = (0, 1)
         rgba_red = (1, 0, 0, 1)
@@ -443,7 +454,7 @@ class TestCTRL:
     def test_ctrl_circ(self):
         """Test only the ``_ctrl_circ`` private method."""
 
-        drawer = MPLDrawer(1, 1)
+        drawer = MPLDrawer(1, {0: 0})
         drawer._ctrl_circ(0, 0)
         circ = drawer.ax.patches[0]
 
@@ -457,7 +468,7 @@ class TestCTRL:
     def test_ctrlo_circ(self):
         """Test only the ``ctrlo_circ`` private method."""
 
-        drawer = MPLDrawer(1, 1)
+        drawer = MPLDrawer(1, {0: 0})
         drawer._ctrlo_circ(0, 0)
         circ = drawer.ax.patches[0]
 
@@ -469,7 +480,7 @@ class TestCTRL:
     def test_ctrl_target(self):
         """Tests target impacts line extent"""
 
-        drawer = MPLDrawer(1, 3)
+        drawer = MPLDrawer(1, {i: i for i in range(3)})
 
         drawer.ctrl(0, 0, 2)
 
@@ -497,14 +508,14 @@ class TestCTRL:
     )
     def test_ctrl_raises_warning_with_overlap(self, control_wires, target_wires):
         """Tests that a warning is raised if some control indicators are not visible."""
-        drawer = MPLDrawer(1, 4)
+        drawer = MPLDrawer(1, {i: i for i in range(4)})
         with pytest.warns(UserWarning, match="control indicators are hidden behind an operator"):
             drawer.ctrl(0, control_wires, target_wires)
         plt.close()
 
     @pytest.mark.parametrize("control_wires,target_wires", [((0,), (1, 2)), ((2,), (0, 1))])
     def test_ctrl_no_warning_without_overlap(self, control_wires, target_wires):
-        drawer = MPLDrawer(1, 3)
+        drawer = MPLDrawer(1, {i: i for i in range(3)})
         with warnings.catch_warnings(record=True) as w:
             drawer.ctrl(0, control_wires, target_wires)
         assert len(w) == 0
@@ -513,7 +524,7 @@ class TestCTRL:
     def test_target_x(self):
         """Tests hidden target_x drawing method"""
 
-        drawer = MPLDrawer(1, 3)
+        drawer = MPLDrawer(1, {i: i for i in range(3)})
 
         drawer._target_x(0, 0)
 
@@ -533,7 +544,7 @@ class TestCTRL:
 
     def test_target_x_color(self):
         """Test the color of target_x."""
-        drawer = MPLDrawer(1, 3)
+        drawer = MPLDrawer(1, {i: i for i in range(3)})
 
         rgba_red = (1, 0, 0, 1)
         drawer._target_x(0, 0, options={"color": rgba_red})
@@ -553,7 +564,7 @@ class TestCTRL:
     def test_CNOT(self):
         """Tests the CNOT method"""
 
-        drawer = MPLDrawer(1, 3)
+        drawer = MPLDrawer(1, {i: i for i in range(3)})
 
         drawer.CNOT(0, (0, 1))
 
@@ -578,7 +589,7 @@ class TestCTRL:
     def test_CNOT_control_values(self):
         """Tests the ``control_values`` keyword for CNOT."""
 
-        drawer = MPLDrawer(1, 3)
+        drawer = MPLDrawer(1, {i: i for i in range(3)})
 
         drawer.CNOT(0, (0, 1, 2), control_values=[True, False])
 
@@ -593,7 +604,7 @@ class TestCTRL:
 
     def test_CNOT_color(self):
         """Tests the color of CNOT."""
-        drawer = MPLDrawer(1, 3)
+        drawer = MPLDrawer(1, {i: i for i in range(3)})
         rgba_red = (1, 0, 0, 1)
         drawer.CNOT(0, (0, 1), options={"color": rgba_red})
 
@@ -618,7 +629,7 @@ class TestSWAP:
     def test_swap_x(self):
         """Tests the ``_swap_x`` private method."""
 
-        drawer = MPLDrawer(1, 1)
+        drawer = MPLDrawer(1, {0: 0})
         drawer._swap_x(0, 0)
 
         l1 = drawer.ax.lines[1]
@@ -631,7 +642,7 @@ class TestSWAP:
     def test_SWAP(self):
         """Tests the SWAP method."""
 
-        drawer = MPLDrawer(1, 3)
+        drawer = MPLDrawer(1, {i: i for i in range(3)})
         drawer.SWAP(0, (0, 2))
 
         connecting_line = drawer.ax.lines[3]
@@ -647,7 +658,7 @@ class TestSWAP:
     def test_SWAP_options(self):
         """Tests that SWAP can be colored."""
 
-        drawer = MPLDrawer(1, 3)
+        drawer = MPLDrawer(1, {i: i for i in range(3)})
         rgba_red = (1, 0, 0, 1)
         options = {"color": rgba_red, "linewidth": 3}
         drawer.SWAP(0, (0, 2), options=options)
@@ -665,7 +676,7 @@ class TestMeasure:
     def test_measure(self):
         """Tests the measure method."""
 
-        drawer = MPLDrawer(1, 1)
+        drawer = MPLDrawer(1, {0: 0})
         drawer.measure(0, 0)
 
         box = drawer.ax.patches[0]
@@ -688,7 +699,7 @@ class TestMeasure:
     def test_measure_multiple_wires(self):
         """Tests the measure method when multiple wires are provided."""
 
-        drawer = MPLDrawer(n_layers=1, n_wires=2)
+        drawer = MPLDrawer(n_layers=1, wire_map={0: 0, 1: 1})
         drawer.measure(layer=0, wires=(0, 1))
 
         box = drawer.ax.patches[0]
@@ -712,7 +723,7 @@ class TestMeasure:
     def test_measure_classical_wires(self):
         """Tests the measure method when multiple wires are provided."""
 
-        drawer = MPLDrawer(n_layers=1, n_wires=2, c_wires=2)
+        drawer = MPLDrawer(n_layers=1, wire_map={0: 0, 1: 1}, c_wires=2)
         drawer.measure(layer=0, wires=(2, 3))
 
         box = drawer.ax.patches[0]
@@ -735,7 +746,7 @@ class TestMeasure:
 
     def test_measure_text(self):
         """Test adding a postselection label to a measure box."""
-        drawer = MPLDrawer(1, 1)
+        drawer = MPLDrawer(1, {0: 0})
         drawer.measure(0, 0, text="0")
         assert len(drawer.ax.texts) == 1
         assert drawer.ax.texts[0].get_text() == "0"
@@ -745,7 +756,7 @@ class TestMeasure:
     def test_measure_formatted(self):
         """Tests you can color the measure box"""
 
-        drawer = MPLDrawer(1, 1)
+        drawer = MPLDrawer(1, {0: 0})
         rgba_red = (1.0, 0, 0, 1.0)
         rgba_green = (0, 1, 0, 1)
         box_options = {"facecolor": rgba_red, "edgecolor": rgba_green}
@@ -794,7 +805,7 @@ class TestAutosize:
     def test_autosize_false(self):
         """Test that the text is unchanged if autosize is set to False."""
 
-        drawer = MPLDrawer(n_layers=1, n_wires=2)
+        drawer = MPLDrawer(n_layers=1, wire_map={0: 0, 1: 1})
         drawer.box_gate(0, (0, 1), text="very very long text", autosize=False)
 
         t = drawer.ax.texts[0]
@@ -807,7 +818,7 @@ class TestAutosize:
         """Test case where the box is on only one wire.  The text should still
         be inside the box, but not rotated."""
 
-        drawer = MPLDrawer(n_layers=1, n_wires=1)
+        drawer = MPLDrawer(n_layers=1, wire_map={0: 0})
         drawer.box_gate(0, 0, text="very very long text", autosize=True)
 
         t = drawer.ax.texts[0]
@@ -821,7 +832,7 @@ class TestAutosize:
         """Test case where the box is on multiple wires.  The text should
         be rotated 90deg, and still inside the box."""
 
-        drawer = MPLDrawer(n_layers=1, n_wires=2)
+        drawer = MPLDrawer(n_layers=1, wire_map={0: 0, 1: 1})
         drawer.box_gate(0, (0, 1), text="very very long text", autosize=True)
 
         t = drawer.ax.texts[0]
@@ -835,7 +846,7 @@ class TestAutosize:
         """Test case where the box is on one wire and the text is skinny and tall.
         If the text is too tall, it should still be shrunk to fit inside the box."""
 
-        drawer = MPLDrawer(n_layers=1, n_wires=1)
+        drawer = MPLDrawer(n_layers=1, wire_map={0: 0})
         drawer.box_gate(0, 0, text="text\nwith\nall\nthe\nlines\nyep", autosize=True)
 
         t = drawer.ax.texts[0]
@@ -850,7 +861,7 @@ class TestAutosize:
         If the text is just too tall and the width fits inside the box, the text should not
         be rotated."""
 
-        drawer = MPLDrawer(n_layers=1, n_wires=2)
+        drawer = MPLDrawer(n_layers=1, wire_map={0: 0, 1: 1})
         drawer.box_gate(
             0,
             (0, 1),
@@ -869,7 +880,7 @@ class TestAutosize:
         """Test case where the box is on multiple wires and text is fat, tall,
         and fatter than it is tall. It should be rotated."""
 
-        drawer = MPLDrawer(n_layers=1, n_wires=2)
+        drawer = MPLDrawer(n_layers=1, wire_map={0: 0, 1: 1})
         drawer.box_gate(0, (0, 1), text="very very long text\nall\nthe\nlines\nyep", autosize=True)
 
         assert self.text_in_box(drawer)
@@ -880,7 +891,7 @@ class TestAutosize:
 class TestClassicalWires:
     def test_classical_wire(self):
         """Test the addition of horiziontal classical wires."""
-        drawer = MPLDrawer(n_wires=1, n_layers=4, c_wires=3)
+        drawer = MPLDrawer(wire_map={0: 0}, n_layers=4, c_wires=3)
 
         layers = [0, 0, 1, 1]
         wires = [0, 1, 1, 0]
@@ -906,7 +917,7 @@ class TestClassicalWires:
 
     def test_cwire_join(self):
         """Test the cwire join method."""
-        drawer = MPLDrawer(n_wires=1, n_layers=4, c_wires=3)
+        drawer = MPLDrawer(wire_map={0: 0}, n_layers=4, c_wires=3)
 
         drawer.cwire_join(1, 2)
 
@@ -920,7 +931,7 @@ class TestClassicalWires:
 
     def test_cwire_join_erase_right(self):
         """Test the cwire join method."""
-        drawer = MPLDrawer(n_wires=1, n_layers=4, c_wires=3)
+        drawer = MPLDrawer(wire_map={0: 0}, n_layers=4, c_wires=3)
 
         drawer.cwire_join(1, 1, erase_right=True)
 
@@ -938,7 +949,7 @@ class TestCond:
 
     def test_cond_basic(self):
         """Tests cond from one wire to the next."""
-        drawer = MPLDrawer(n_wires=2, n_layers=2)
+        drawer = MPLDrawer(wire_map={0: 0, 1: 1}, n_layers=2)
         wire_data_before = [line.get_data() for line in drawer._wire_lines]
 
         drawer.cond(layer=1, measured_layer=0, wires=[0], wires_target=[1])
@@ -957,7 +968,7 @@ class TestCond:
 
     def test_cond_two_ctrl_wires(self):
         """Tests cond from two separated wires."""
-        drawer = MPLDrawer(n_wires=4, n_layers=2)
+        drawer = MPLDrawer(wire_map={i: i for i in range(4)}, n_layers=2)
         drawer.cond(layer=1, measured_layer=0, wires=[0, 2], wires_target=[3])
         actual_data = [line.get_data() for line in drawer.ax.lines]
 
@@ -978,7 +989,7 @@ class TestCond:
 
     def test_cond_two_ctrl_wires_upward(self):
         """Test cond when the conditional operation is above the control wires."""
-        drawer = MPLDrawer(n_wires=3, n_layers=2)
+        drawer = MPLDrawer(wire_map={i: i for i in range(3)}, n_layers=2)
         drawer.cond(layer=1, measured_layer=0, wires=[1, 2], wires_target=[0])
         actual_data = [line.get_data() for line in drawer.ax.lines]
         assert actual_data == [
@@ -1006,7 +1017,7 @@ class TestCond:
     )
     def test_cond_fail_with_bad_order(self, ctrl_wires, target_wires):
         """Tests cond raises an error when the wires aren't neatly separated."""
-        drawer = MPLDrawer(n_wires=4, n_layers=2)
+        drawer = MPLDrawer(wire_map={i: i for i in range(4)}, n_layers=2)
         with pytest.raises(ValueError, match="Cannot draw interspersed mid-circuit measurements"):
             drawer.cond(layer=1, measured_layer=0, wires=ctrl_wires, wires_target=target_wires)
         plt.close()
diff --git a/tests/test_debugging.py b/tests/test_debugging.py
index 46fcb59f9..a07cb29a5 100644
--- a/tests/test_debugging.py
+++ b/tests/test_debugging.py
@@ -401,7 +401,7 @@ class TestSnapshotSupportedQNode:
         )
         assert result["execution_results"] == expected["execution_results"]
 
-        # Make sure shots are overriden correctly
+        # Make sure shots are overridden correctly
         result = qml.snapshots(circuit)(add_bad_snapshot=False, shots=200)
         assert result[0] == {"00": 74, "10": 58, "20": 68}
 
@@ -555,7 +555,7 @@ class TestSnapshotSupportedQNode:
 
         _compare_numpy_dicts(result, expected)
 
-        # Make sure shots are overriden correctly
+        # Make sure shots are overridden correctly
         result = qml.snapshots(circuit)(shots=200)
         assert result[3] == {"0": 98, "1": 102}
         assert np.allclose(result[5], expected[5])
@@ -612,7 +612,7 @@ class TestSnapshotUnsupportedQNode:
         assert ttest_ind([count["0"] for count in counts], 250).pvalue >= 0.75
         assert ttest_ind(expvals, 0.0).pvalue >= 0.75
 
-        # Make sure shots are overriden correctly
+        # Make sure shots are overridden correctly
         counts, _ = tuple(zip(*(qml.snapshots(circuit)(shots=1000).values() for _ in range(50))))
         assert ttest_ind([count["0"] for count in counts], 500).pvalue >= 0.75
 
@@ -687,7 +687,7 @@ class TestSnapshotUnsupportedQNode:
 
         _compare_numpy_dicts(result, expected)
 
-        # Make sure shots are overriden correctly
+        # Make sure shots are overridden correctly
         result = circuit(shots=200)
         assert np.allclose(
             result[0],
diff --git a/tests/test_vqe.py b/tests/test_vqe.py
index 8ef5b2749..483c9254f 100644
--- a/tests/test_vqe.py
+++ b/tests/test_vqe.py
@@ -415,9 +415,9 @@ class TestVQE:
             qml.PauliZ(wires=[4]) @ qml.PauliZ(wires=[3]),
         ]
 
-        coefs = (np.random.rand(len(obs)) - 0.5) * 2
-        hamiltonian1 = qml.Hamiltonian(coefs, obs)
-        hamiltonian2 = qml.Hamiltonian(coefs, obs)
+        coeffs = (np.random.rand(len(obs)) - 0.5) * 2
+        hamiltonian1 = qml.Hamiltonian(coeffs, obs)
+        hamiltonian2 = qml.Hamiltonian(coeffs, obs)
         hamiltonian1.compute_grouping()
 
         cost = generate_cost_fn(
@@ -471,9 +471,9 @@ class TestVQE:
             qml.PauliZ(wires=[4]) @ qml.PauliZ(wires=[3]),
         ]
 
-        coefs = (np.random.rand(len(obs)) - 0.5) * 2
-        hamiltonian1 = qml.Hamiltonian(coefs, obs)
-        hamiltonian2 = qml.Hamiltonian(coefs, obs)
+        coeffs = (np.random.rand(len(obs)) - 0.5) * 2
+        hamiltonian1 = qml.Hamiltonian(coeffs, obs)
+        hamiltonian2 = qml.Hamiltonian(coeffs, obs)
         hamiltonian1.compute_grouping()
 
         cost = generate_cost_fn(
@@ -527,9 +527,9 @@ class TestVQE:
             qml.PauliZ(wires=[4]) @ qml.PauliZ(wires=[3]),
         ]
 
-        coefs = (np.random.rand(len(obs)) - 0.5) * 2
-        hamiltonian1 = qml.Hamiltonian(coefs, obs)
-        hamiltonian2 = qml.Hamiltonian(coefs, obs)
+        coeffs = (np.random.rand(len(obs)) - 0.5) * 2
+        hamiltonian1 = qml.Hamiltonian(coeffs, obs)
+        hamiltonian2 = qml.Hamiltonian(coeffs, obs)
         hamiltonian1.compute_grouping()
 
         cost = generate_cost_fn(
diff --git a/tests/workflow/interfaces/test_jacobian_products.py b/tests/workflow/interfaces/test_jacobian_products.py
index 1991ba2d5..9a090d3af 100644
--- a/tests/workflow/interfaces/test_jacobian_products.py
+++ b/tests/workflow/interfaces/test_jacobian_products.py
@@ -273,7 +273,7 @@ class TestJacobianProductResults:
             pytest.skip("jpc does not work with finite shots.")
         if jpc is hadamard_grad_jpc and qml.measurements.Shots(shots).has_partitioned_shots:
             pytest.skip(
-                "hadamard gradient does not support multiple measurments with partitioned shots."
+                "hadamard gradient does not support multiple measurements with partitioned shots."
             )
 
         x = 0.385