Merging dev into master (#1353)

Merging the dev branch into the master branch for the release of PL 0.41

---------

Co-authored-by: GitHub Nightly Merge Action <actions@github.com>
Co-authored-by: Andrija Paurevic <46359773+andrijapau@users.noreply.github.com>
Co-authored-by: Yushao Chen (Jerry) <chenys13@outlook.com>
Co-authored-by: Alex Preciado <alex.preciado@xanadu.ai>
Co-authored-by: Isaac De Vlugt <isaacdevlugt@gmail.com>
Co-authored-by: Korbinian Kottmann <43949391+Qottmann@users.noreply.github.com>
Co-authored-by: David Wierichs <davidwierichs@gmail.com>
Co-authored-by: Josh Izaac <josh146@gmail.com>
Co-authored-by: Isaac De Vlugt <34751083+isaacdevlugt@users.noreply.github.com>
Co-authored-by: Christina Lee <chrissie.c.l@gmail.com>

Author: 10 people

_static/demonstration_assets/qnn_module/sphx_glr_qnn_module_tf_001.png

@@ -6,7 +6,7 @@
         }
     ],
     "dateOfPublication": "2020-11-02T00:00:00+00:00",
-    "dateOfLastModification": "2024-10-07T00:00:00+00:00",
+    "dateOfLastModification": "2025-03-21T00:00:00+00:00",
     "categories": [
         "Devices and Performance",
         "Quantum Machine Learning"

demonstrations/tutorial_qnn_module_tf.metadata.json renamed to demonstrations/qnn_module_tf.metadata.json

@@ -1,4 +1,7 @@
-"""
+r"""
+.. role:: html(raw)
+    :format: html
+
 Turning quantum nodes into Keras Layers
 =======================================
 
@@ -10,7 +13,13 @@
 
    tutorial_qnn_module_torch Turning quantum nodes into Torch Layers
 
-*Author: Tom Bromley — Posted: 02 November 2020. Last updated: 28 January 2021.*
+*Author: Tom Bromley — Posted: 02 November 2020. Last updated: 21 March 2025.*
+
+.. warning::
+
+    This demo is only compatible with PennyLane version 0.40 or below.
+    For usage with a later version of PennyLane, please consider using
+    :doc:`PyTorch </demos/tutorial_qnn_module_torch>` or :doc:`JAX </demos/tutorial_How_to_optimize_QML_model_using_JAX_and_Optax>`.
 
 Creating neural networks in `Keras <https://keras.io/>`__ is easy. Models are constructed from
 elementary *layers* and can be trained using a high-level API. For example, the following code
@@ -67,6 +76,11 @@
 plt.scatter(X[:, 0], X[:, 1], c=c)
 plt.show()
 
+##############################################################################
+# .. figure:: /_static/demonstration_assets/qnn_module/sphx_glr_qnn_module_tf_001.png
+#    :width: 100%
+#    :align: center
+
 ###############################################################################
 # Defining a QNode
 # ----------------
@@ -166,7 +180,25 @@ def qnode(inputs, weights):
 
 fitting = model.fit(X, y_hot, epochs=6, batch_size=5, validation_split=0.25, verbose=2)
 
-###############################################################################
+##############################################################################
+# .. rst-class:: sphx-glr-script-out
+#
+#  .. code-block:: none
+#
+#    Epoch 1/6
+#    30/30 - 4s - loss: 0.4153 - accuracy: 0.7333 - val_loss: 0.3183 - val_accuracy: 0.7800 - 4s/epoch - 123ms/step
+#    Epoch 2/6
+#    30/30 - 4s - loss: 0.2927 - accuracy: 0.8000 - val_loss: 0.2475 - val_accuracy: 0.8400 - 4s/epoch - 130ms/step
+#    Epoch 3/6
+#    30/30 - 4s - loss: 0.2272 - accuracy: 0.8333 - val_loss: 0.2111 - val_accuracy: 0.8200 - 4s/epoch - 119ms/step
+#    Epoch 4/6
+#    30/30 - 4s - loss: 0.1963 - accuracy: 0.8667 - val_loss: 0.1917 - val_accuracy: 0.8600 - 4s/epoch - 118ms/step
+#    Epoch 5/6
+#    30/30 - 4s - loss: 0.1772 - accuracy: 0.8667 - val_loss: 0.1828 - val_accuracy: 0.8600 - 4s/epoch - 117ms/step
+#    Epoch 6/6
+#    30/30 - 4s - loss: 0.1603 - accuracy: 0.8733 - val_loss: 0.2006 - val_accuracy: 0.8200 - 4s/epoch - 117ms/step
+#
+#
 # How did we do? The model looks to have successfully trained and the accuracy on both the
 # training and validation datasets is reasonably high. In practice, we would aim to push the
 # accuracy higher by thinking carefully about the model design and the choice of hyperparameters
@@ -224,7 +256,25 @@ def qnode(inputs, weights):
 
 fitting = model.fit(X, y_hot, epochs=6, batch_size=5, validation_split=0.25, verbose=2)
 
-###############################################################################
+##############################################################################
+# .. rst-class:: sphx-glr-script-out
+#
+#  .. code-block:: none
+#
+#    Epoch 1/6
+#    30/30 - 7s - loss: 0.3682 - accuracy: 0.7467 - val_loss: 0.2550 - val_accuracy: 0.8000 - 7s/epoch - 229ms/step
+#    Epoch 2/6
+#    30/30 - 7s - loss: 0.2428 - accuracy: 0.8067 - val_loss: 0.2105 - val_accuracy: 0.8400 - 7s/epoch - 224ms/step
+#    Epoch 3/6
+#    30/30 - 7s - loss: 0.2001 - accuracy: 0.8333 - val_loss: 0.1901 - val_accuracy: 0.8200 - 7s/epoch - 220ms/step
+#    Epoch 4/6
+#    30/30 - 7s - loss: 0.1816 - accuracy: 0.8600 - val_loss: 0.1776 - val_accuracy: 0.8200 - 7s/epoch - 224ms/step
+#    Epoch 5/6
+#    30/30 - 7s - loss: 0.1661 - accuracy: 0.8667 - val_loss: 0.1711 - val_accuracy: 0.8600 - 7s/epoch - 224ms/step
+#    Epoch 6/6
+#    30/30 - 7s - loss: 0.1520 - accuracy: 0.8600 - val_loss: 0.1807 - val_accuracy: 0.8200 - 7s/epoch - 221ms/step
+#
+#
 # Great! We've mastered the basics of constructing hybrid classical-quantum models using
 # PennyLane and Keras. Can you think of any interesting hybrid models to construct? How do they
 # perform on realistic datasets?

demonstrations/tutorial_qnn_module_tf.py renamed to demonstrations/qnn_module_tf.py

@@ -9,7 +9,7 @@
         }
     ],
     "dateOfPublication": "2022-10-31T00:00:00+00:00",
-    "dateOfLastModification": "2024-12-13T00:00:00+00:00",
+    "dateOfLastModification": "2025-01-23T00:00:00+00:00",
     "categories": [
         "Quantum Chemistry"
     ],

demonstrations/tutorial_classically_boosted_vqe.metadata.json

@@ -449,7 +449,7 @@ def hadamard_test(Uq, Ucl, component="real"):
 
     qml.Hadamard(wires=[0])
     qml.ControlledQubitUnitary(
-        Uq.conjugate().T @ Ucl, control_wires=[0], wires=wires[1:]
+        Uq.conjugate().T @ Ucl, wires=wires
     )
     qml.Hadamard(wires=[0])
 

demonstrations/tutorial_classically_boosted_vqe.py

@@ -6,7 +6,7 @@
         }
     ],
     "dateOfPublication": "2024-12-19T00:00:00+00:00",
-    "dateOfLastModification": "2025-01-10T00:00:00+00:00",
+    "dateOfLastModification": "2025-04-11T00:00:00+00:00",
     "categories": [
         "Quantum Computing",
         "Algorithms"

demonstrations/tutorial_fixed_depth_hamiltonian_simulation_via_cartan_decomposition.metadata.json

@@ -20,7 +20,7 @@
 Introduction
 ------------
 
-The :doc:`KAK theorem </demos/tutorial_kak_decomposition>` is an important result from Lie theory that states that any Lie group element :math:`U` can be decomposed
+The :doc:`KAK decomposition </demos/tutorial_kak_decomposition>` is an important result from Lie theory that states that any Lie group element :math:`U` can be decomposed
 as :math:`U = K_1 A K_2,` where :math:`K_{1, 2}` and :math:`A` are elements of two special sub-groups
 :math:`\mathcal{K}` and :math:`\mathcal{A},` respectively. In special cases, the decomposition simplifies to :math:`U = K A K^\dagger.`
 
@@ -36,14 +36,14 @@
 We can use this general result from Lie theory as a powerful circuit decomposition technique.
 
 .. note:: We recommend a basic understanding of Lie algebras, see e.g. our :doc:`introduction to (dynamical) Lie algebras for quantum practitioners </demos/tutorial_liealgebra>`.
-    Otherwise, this demo should be self-contained, though for the mathematically inclined, we further recommend our :doc:`demo on the KAK theorem </demos/tutorial_kak_decomposition>`
-    that dives into the mathematical depths of the theorem and provides more background info.
+    Otherwise, this demo should be self-contained, though for the mathematically inclined, we further recommend our :doc:`demo on the KAK decomposition </demos/tutorial_kak_decomposition>`
+    that dives into the mathematical depths of the decomposition and provides more background info.
 
 Goal: Fast-forwarding time evolutions using the KAK decomposition
 -----------------------------------------------------------------
 
 Unitary gates in quantum computing are described by the special unitary Lie group :math:`SU(2^n),` so we can use the KAK
-theorem to decompose quantum gates into :math:`U = K_1 A K_2.` While the mathematical statement is rather straightforward,
+decomposition to factorize quantum gates into :math:`U = K_1 A K_2.` While the mathematical statement is rather straightforward,
 actually finding this decomposition is not. We are going to follow the recipe prescribed in 
 `Fixed Depth Hamiltonian Simulation via Cartan Decomposition <https://arxiv.org/abs/2104.00728>`__ [#Kökcü]_, 
 which tackles this decomposition on the level of the associated Lie algebra via Cartan decomposition.
@@ -74,6 +74,7 @@
 import numpy as np
 import pennylane as qml
 from pennylane import X, Y, Z
+from pennylane.liealg import even_odd_involution, cartan_decomp, horizontal_cartan_subalgebra
 
 import jax
 import jax.numpy as jnp
@@ -111,10 +112,8 @@
 # One common choice of involution is the so-called even-odd involution for Pauli words,
 # :math:`P = P_1 \otimes P_2 .. \otimes P_n,` where :math:`P_j \in \{I, X, Y, Z\}.`
 # It essentially counts whether the number of non-identity Pauli operators in the Pauli word is even or odd.
-
-def even_odd_involution(op):
-    [pw] = op.pauli_rep
-    return len(pw) % 2
+# It is readily available in PennyLane as :func:`~.pennylane.liealg.even_odd_involution`, which 
+# we already imported above.
 
 even_odd_involution(X(0)), even_odd_involution(X(0) @ Y(3))
 
@@ -126,30 +125,9 @@ def even_odd_involution(op):
 # sort the operators by whether or not they yield a plus or minus sign from the involution function.
 # This is possible because the operators and involution nicely align with the eigenspace decomposition.
 
-def cartan_decomposition(g, involution):
-    """Cartan Decomposition g = k + m
-    
-    Args:
-        g (List[PauliSentence]): the (dynamical) Lie algebra to decompose
-        involution (callable): Involution function :math:`\Theta(\cdot)` to act on PauliSentence ops, should return ``0/1`` or ``True/False``.
-    
-    Returns:
-        k (List[PauliSentence]): the vertical subspace :math:`\Theta(x) = x`
-        m (List[PauliSentence]): the horizontal subspace :math:`\Theta(x) = -x` """
-    m = []
-    k = []
-
-    for op in g:
-        if involution(op): # vertical space when involution returns True
-            k.append(op)
-        else: # horizontal space when involution returns False
-            m.append(op)
-    return k, m
-
-k, m = cartan_decomposition(g, even_odd_involution)
+k, m = cartan_decomp(g, even_odd_involution)
 len(g), len(k), len(m)
 
-
 ##############################################################################
 # We have successfully decomposed the 60-dimensional Lie algebra
 # into a 24-dimensional vertical subspace and a 36-dimensional subspace.
@@ -187,51 +165,11 @@ def cartan_decomposition(g, involution):
 # that commute with it.
 #
 # We then obtain a further split of the vector space :math:`\mathfrak{m} = \tilde{\mathfrak{m}} \oplus \mathfrak{h},`
-# where :math:`\tilde{\mathfrak{m}}` is just the remainder of :math:`\mathfrak{m}.`
+# where :math:`\tilde{\mathfrak{m}}` is just the remainder of :math:`\mathfrak{m}.` The function
+# :func:`~.pennylane.liealg.horizontal_cartan_subalgebra` returns some additional information, which we will
+# not use here.
 
-def _commutes_with_all(candidate, ops):
-    r"""Check if ``candidate`` commutes with all ``ops``"""
-    for op in ops:
-        com = candidate.commutator(op)
-        com.simplify()
-        
-        if not len(com) == 0:
-            return False
-    return True
-
-def cartan_subalgebra(m, which=0):
-    """Compute the Cartan subalgebra from the horizontal subspace :math:`\mathfrak{m}`
-    of the Cartan decomposition
-
-    This implementation is specific for cases of bases of m with pure Pauli words as
-    detailed in Appendix C in `2104.00728 <https://arxiv.org/abs/2104.00728>`__.
-    
-    Args:
-        m (List[PauliSentence]): the horizontal subspace :math:`\Theta(x) = -x
-        which (int): Choice for the initial element of m from which to construct 
-            the maximal Abelian subalgebra
-    
-    Returns:
-        mtilde (List): remaining elements of :math:`\mathfrak{m}`
-            s.t. :math:`\mathfrak{m} = \tilde{\mathfrak{m}} \oplus \mathfrak{h}`.
-        h (List): Cartan subalgebra :math:`\mathfrak{h}`.
-
-    """
-
-    h = [m[which]] # first candidate
-    mtilde = m.copy()
-
-    for m_i in m:
-        if _commutes_with_all(m_i, h):
-            if m_i not in h:
-                h.append(m_i)
-    
-    for h_i in h:
-        mtilde.remove(h_i)
-    
-    return mtilde, h
-
-mtilde, h = cartan_subalgebra(m)
+g, k, mtilde, h, _ = horizontal_cartan_subalgebra(k, m, tol=1e-8)
 len(g), len(k), len(mtilde), len(h)
 
 ##############################################################################
@@ -241,7 +179,7 @@ def cartan_subalgebra(m, which=0):
 # Variational KhK decomposition
 # -----------------------------
 #
-# The KAK theorem is not constructive in the sense that it proves that there exists such a decomposition, but there is no general way of obtaining
+# The KAK decomposition is not constructive in the sense that it proves that there exists such a decomposition, but there is no general way of obtaining
 # it. In particular, there are no linear algebra subroutines implemented in ``numpy`` or ``scipy`` that just compute it for us.
 # Here, we follow the construction of [#Kökcü]_ for the special case of :math:`H` being in the horizontal space and the decomposition
 # simplifying to :math:`H = K^\dagger h K`.
@@ -282,10 +220,10 @@ def cartan_subalgebra(m, which=0):
 #
 
 def run_opt(
-    value_and_grad,
+    loss,
     theta,
-    n_epochs=500,
-    lr=0.1,
+    n_epochs=1000,
+    lr=0.05,
 ):
     """Boilerplate JAX optimization"""
     value_and_grad = jax.jit(jax.value_and_grad(loss))
@@ -336,7 +274,7 @@ def loss(theta):
     A = K_m @ v_m @ K_m.conj().T
     return jnp.trace(A.conj().T @ H_m).real
 
-theta0 = jnp.ones(len(k), dtype=float)
+theta0 = jax.random.normal(jax.random.PRNGKey(0), shape=(len(k),), dtype=float)
 
 thetas, energy, _ = run_opt(loss, theta0, n_epochs=1000, lr=0.05)
 plt.plot(energy - np.min(energy))
@@ -359,13 +297,18 @@ def loss(theta):
 # .. math:: h_0 = K_c^\dagger H K_c.
 
 h_0_m = Kc_m.conj().T @ H_m @ Kc_m
-h_0 = qml.pauli_decompose(h_0_m)
 
-print(len(h_0))
+# decompose h_0_m in terms of the basis of h
+basis = [qml.matrix(op, wire_order=range(n_wires)) for op in h]
+coeffs = qml.pauli.trace_inner_product(h_0_m, basis)
+
+# ensure that decomposition is correct, i.e. h_0_m is truely an element of just h
+h_0_m_recomposed = np.sum([c * op for c, op in zip(coeffs, basis)], axis=0)
+print("Decomposition of h_0 is faithful: ", np.allclose(h_0_m_recomposed, h_0_m, atol=1e-10))
+
+# sanity check that the horizontal CSA is Abelian, i.e. all its elements commute
+print("All elements in h commute with each other: ", qml.liealg.check_abelian(h))
 
-# assure that h_0 is in \mathfrak{h}
-h_vspace = qml.pauli.PauliVSpace(h)
-not h_vspace.is_independent(h_0.pauli_rep)
 
 ##############################################################################
 #
@@ -393,6 +336,7 @@ def loss(theta):
 t = 1.
 U_exact = qml.exp(-1j * t * H)
 U_exact_m = qml.matrix(U_exact, wire_order=range(n_wires))
+h_0  = qml.dot(coeffs, h)
 
 def U_kak(theta_opt, t):
     qml.adjoint(K)(theta_opt, k)
@@ -478,7 +422,7 @@ def compute_res(Us):
 # Conclusion
 # ----------
 #
-# The KAK theorem is a very general mathematical result with far-reaching consequences.
+# The KAK decomposition is a very general mathematical result with far-reaching consequences.
 # While there is no canonical way of obtaining an actual decomposition in practice, we followed
 # the approach of [#Kökcü]_ which uses a specifically designed loss function and variational
 # optimization to find the decomposition.

demonstrations/tutorial_fixed_depth_hamiltonian_simulation_via_cartan_decomposition.py

@@ -6,7 +6,7 @@
         }
     ],
     "dateOfPublication": "2024-11-25T00:00:00+00:00",
-    "dateOfLastModification": "2025-01-07T09:00:00+00:00",
+    "dateOfLastModification": "2025-03-26T09:00:00+00:00",
     "categories": [
         "Quantum Computing",
         "Algorithms"

demonstrations/tutorial_kak_decomposition.metadata.json

@@ -348,14 +348,15 @@ def is_orthogonal(op, basis):
 #
 # Let us define it in code, and check whether it gives rise to a Cartan decomposition.
 # As we want to look at another example later, we wrap everything in a function.
+# A similar function is available in PennyLane as :func:`~.pennylane.liealg.check_cartan_decomp`.
 #
 
 
-def check_cartan_decomposition(g, k, space_name):
+def check_cartan_decomp(g, k, space_name):
     """Given an algebra g and an operator subspace k, verify that k is a subalgebra
-    and gives rise to a Cartan decomposition."""
+    and gives rise to a Cartan decomposition. Similar to qml.liealg.check_cartan_decomp"""
     # Check Lie closure of k
-    k_lie_closure = qml.pauli.dla.lie_closure(k)
+    k_lie_closure = qml.lie_closure(k)
     k_is_closed = len(k_lie_closure) == len(k)
     print(f"The Lie closure of k is as big as k itself: {k_is_closed}.")
 
@@ -387,7 +388,7 @@ def check_cartan_decomposition(g, k, space_name):
 
 u1 = [Z(0)]
 space_name = "SU(2)/U(1)"
-p = check_cartan_decomposition(su2, u1, space_name)
+p = check_cartan_decomp(su2, u1, space_name)
 
 ######################################################################
 # Cartan subalgebras
@@ -811,7 +812,7 @@ def theta_Y(x):
 # Define subalgebra su(2) ⊕ su(2)
 su2_su2 = [X(0), Y(0), Z(0), X(1), Y(1), Z(1)]
 space_name = "SU(4)/(SU(2)xSU(2))"
-p = check_cartan_decomposition(su4, su2_su2, space_name)
+p = check_cartan_decomp(su4, su2_su2, space_name)
 
 ######################################################################
 # .. admonition:: Math detail: involution for two-qubit decomposition

demonstrations/tutorial_kak_decomposition.py

@@ -6,7 +6,7 @@
         }
     ],
     "dateOfPublication": "2024-06-07T00:00:00+00:00",
-    "dateOfLastModification": "2024-10-07T00:00:00+00:00",
+    "dateOfLastModification": "2025-03-17T00:00:00+00:00",
     "categories": [
         "Quantum Computing",
         "Getting Started"