Update qsvt demos (#1522)

Updating a couple of QSVT demos after we got the following feedback

* Intro to QSVT - drawing gave a black box QSVT/QSP circuit - would like
to see a clear+explained circuit diagram
* Added a `qml.draw_mpl` call that shows the decomposition and
alternating structure of QSVT. Added language about quantum circuits
around that section linking the structure of the diagram to the
equations.
* Intro to QSVT - would like more explanation on transition from scalar
to matrix (small a to capital A)
* Added a small sentence about block encodings. But this could still be
explained more
* Intro to QSVT - confusion about what how each point in the graph is
obtained - explain that each one is a different circuit that encodes a
different value
  * Expanded the description in the legends and the text.
* QSVT in Practice - difficult to follow the difference between x and
vector x (P(X) = s * 1/x)
  * Added a note emphasizing this difference

Also fixes an [issue with an incorrect
formula](https://discuss.pennylane.ai/t/qsvt-for-odd-degree-polynomial-mathematical-expansion/9224)

---------

Co-authored-by: Paul Finlay <50180049+doctorperceptron@users.noreply.github.com>
Co-authored-by: Daniela Angulo <42325731+daniela-angulo@users.noreply.github.com>

Author: 3 people

demonstrations_v2/tutorial_apply_qsvt/demo.py

@@ -76,6 +76,12 @@ def my_circuit():
 # This ultimately requires computing :math:`\vec{x} = A^{-1} \cdot \vec{b},` where for simplicity we
 # assume that :math:`A` is invertible.
 #
+# .. note::
+#     Follow the notation in this section carefully. 
+#     :math:`x` is a scalar and :math:`\vec{x}` is a vector. Sometimes we talk about the scalar
+#     function :math:`P(x) = s \cdot \frac{1}{x}` and sometimes we talk about the vector
+#     function :math:`A \cdot \vec{x} = \vec{b}.` 
+#
 # :math:`A^{-1}` can be constructed directly by inverting the singular values of :math:`A^{T}.` We can
 # leverage QSVT to accomplish this by finding the phase angles which apply a polynomial approximation
 # to the transformation :math:`\frac{1}{x}.` This may seem simple in theory, but in practice there are

demonstrations_v2/tutorial_apply_qsvt/metadata.json

@@ -11,7 +11,7 @@
     "executable_stable": true,
     "executable_latest": true,
     "dateOfPublication": "2023-08-22T00:00:00+00:00",
-    "dateOfLastModification": "2025-09-22T15:48:14+00:00",
+    "dateOfLastModification": "2026-02-23T15:48:14+00:00",
     "categories": [
         "Quantum Computing",
         "Algorithms",

demonstrations_v2/tutorial_intro_qsvt/demo.py

@@ -88,11 +88,16 @@
 
 Let's look at a simple example of how quantum signal processing can be implemented using
 PennyLane. We aim to perform a transformation by the Legendre polynomial
-:math:`(5 x^3 - 3x)/2`.
+:math:`P(a) = (5 a^3 - 3a)/2`.
 As you will soon learn, QSP can be viewed as a special case of QSVT. We thus use the :func:`~.pennylane.qsvt`
-operation to construct the output matrix and compare the resulting transformation to
-the target polynomial.
+operation to construct the matrix representation of the QSP transformation. In the code below, we build one matrix
+for each value of :math:`a` that we test. If the top-left entry of the matrix matches :math:`P(a)` for all
+input values, then our QSP transformation successfully implements the desired matrix,
 
+.. math:: \begin{pmatrix}
+    P(a) & *\\
+    * & *
+    \end{pmatrix}.
 """
 
 import pennylane as qml
@@ -113,8 +118,9 @@ def qsvt_output(a):
 qsvt = [np.real(qsvt_output(a)) for a in a_vals]  # neglect small imaginary part
 target = [np.polyval(target_poly[::-1], a) for a in a_vals]  # evaluate polynomial
 
-plt.plot(a_vals, target, label="target")
-plt.plot(a_vals, qsvt, "*", label="qsvt")
+plt.plot(a_vals, target, label="target polynomial: (5a^3 - 3a)/2")
+plt.plot(a_vals, qsvt, "*", label="QSP: top left entry of matrix")
+plt.xlabel('a')
 
 plt.legend()
 plt.show()
@@ -143,7 +149,8 @@ def qsvt_output(a):
 #
 # Any such method of encoding a matrix inside a larger unitary is known as a **block encoding**. In our construction,
 # the matrix :math:`A` is encoded in the top-left block, hence the name. PennyLane supports
-# the :class:`~pennylane.BlockEncode` operation that follows the construction above. Let's test
+# the :class:`~pennylane.BlockEncode` operation that follows the construction above. This operation serves to block-encode
+# both scalars and matrices. Let's test
 # it out with an example encoding first a square matrix:
 
 # square matrix
@@ -225,7 +232,7 @@ def qsvt_output(a):
 # where we use braket notation to denote the left and right singular vectors.
 # For technical reasons, the sequence looks slightly different when the polynomial degree is odd:
 #
-# .. math:: \tilde{\Pi}_{\phi_1}\left[\prod_{k=1}^{(d-1)/2}\Pi_{\phi_{2k}}U(A)^\dagger \tilde{\Pi}_{\phi_{2k+1}} U(A)\right]\Pi_{\phi_{d+1}}=
+# .. math:: \tilde{\Pi}_{\phi_1}U(A)\left[\prod_{k=1}^{(d-1)/2}\Pi_{\phi_{2k}}U(A)^\dagger \tilde{\Pi}_{\phi_{2k+1}} U(A)\right]\Pi_{\phi_{d+1}}=
 #    \begin{pmatrix}
 #    P(A) & *\\
 #    * & *
@@ -241,22 +248,32 @@ def qsvt_output(a):
 # implemented in polynomial time in the number of qubits, the resulting
 # quantum algorithm will also run in polynomial time. This is very powerful.
 #
-# In PennyLane, implementing the QSVT transformation is as simple as using :func:`~.pennylane.qsvt`. Let's revisit
+# In PennyLane, implementing a quantum circuit for the QSVT transformation is as simple as using :func:`~.pennylane.qsvt`.
+# Under the hood, it uses :class:`~pennylane.BlockEncode` and :class:`~pennylane.PCPhase` operations to implement QSVT as described
+# in the equations above. Now let's revisit
 # our previous example and transform a matrix according to the same Legendre polynomial. We'll use a diagonal matrix
 # with eigenvalues evenly distributed between -1 and 1, allowing us to easily check the transformation.
 
-
 eigvals = np.linspace(-1, 1, 16)
 A = np.diag(eigvals)  # 16-dim matrix
 wire_order = list(range(5))
+
+qml.draw_mpl(qml.transforms.decompose(qml.qsvt))(A,  target_poly, encoding_wires=wire_order, block_encoding="embedding")
+plt.show()
+
+###############################################################################
+# Now, let's see how each eigenvalue of :math:`A` is transformed by QSVT. We will plot the original eigenvalues
+# and the corresponding eigenvalues of the top-left block of the QSVT matrix. 
+
 U_A = qml.matrix(qml.qsvt, wire_order=wire_order)(
     A, target_poly, encoding_wires=wire_order, block_encoding="embedding"
 )  # block-encoded in 5-qubit system
 
 qsvt_A = np.real(np.diagonal(U_A))[:16]  # retrieve transformed eigenvalues
 
-plt.plot(a_vals, target, label="target")
-plt.plot(eigvals, qsvt_A, "*", label="qsvt")
+plt.plot(a_vals, target, label="target polynomial: (5a^3 - 3a)/2")
+plt.plot(eigvals, qsvt_A, "*", label="eigenvalue after QSVT")
+plt.xlabel('a, eigenvalue before transformation')
 
 plt.legend()
 plt.show()

demonstrations_v2/tutorial_intro_qsvt/metadata.json

@@ -8,7 +8,7 @@
     "executable_stable": true,
     "executable_latest": true,
     "dateOfPublication": "2023-05-23T00:00:00+00:00",
-    "dateOfLastModification": "2025-09-22T15:48:14+00:00",
+    "dateOfLastModification": "2026-02-23T15:48:14+00:00",
     "categories": [
         "Algorithms",
         "Quantum Computing"