[labs.dla 3] structure_constants_dense

pennylane/labs/lie/__init__.py

@@ -14,3 +14,4 @@
 """Experimental Lie theory features"""
 
 from .lie_closure import lie_closure_dense
+from .structure_constants import structure_constants_dense

pennylane/labs/lie/structure_constants.py

@@ -0,0 +1,70 @@
+# Copyright 2024 Xanadu Quantum Technologies Inc.
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""A function to compute the structure constants that make up the adjoint representation of a Lie algebra"""
+
+import numpy as np
+
+from pennylane.typing import TensorLike
+
+
+def structure_constants_dense(g: TensorLike) -> TensorLike:
+    r"""
+    Compute the structure constants that make up the adjoint representation of a Lie algebra.
+
+    This function computes the structure constants of a Lie algebra provided by their dense matrix representation,
+    obtained from, e.g., :func:`~lie_closure_dense`.
+    This is sometimes more efficient than using the sparse Pauli representations of :class:`~PauliWord` and
+    `~PauliSentence` that are employed in :func:`~structure_constants`, e.g., when ther are few but dense sums of Paulis.
+
+    .. seealso:: For details on the mathematical definitions, see :func:`~structure_constants` and the section "Lie algebra basics" in our `g-sim demo <https://pennylane.ai/qml/demos/tutorial_liesim/#lie-algebra-basics>`__.
+
+    Args:
+        g (np.array): The (dynamical) Lie algebra provided as dense matrices, as generated from :func:`pennylane.labs.lie.lie_closure_dense`.
+
+    Returns:
+        TensorLike: The adjoint representation of shape ``(d, d, d)``, corresponding to indices ``(gamma, alpha, beta)``.
+
+    **Example**
+
+    Let us generate the DLA of the transverse field Ising model using :func:`~lie_closure_dense`.
+
+    >>> n = 4
+    >>> gens = [X(i) @ X(i+1) + Y(i) @ Y(i+1) + Z(i) @ Z(i+1) for i in range(n-1)]
+    >>> g = lie_closure_dense(gens)
+    >>> g.shape
+    (12, 16, 16)
+
+    The DLA is represented by a collection of twelve :math:`2^4 \times 2^4` matrices.
+    Hence, the dimension of the DLA is :math:`d = 12`. Hence, the structure constants have shape ``(12, 12, 12)``.
+
+    >>> adj = structure_constants_dense(g)
+    >>> adj.shape
+    (12, 12, 12)
+
+    """
+    dimg, chi, _ = g.shape
+
+    # compute all commutators
+    prod = np.einsum("aij,bjk->abik", g, g)
+    m0m1 = np.reshape(prod, (-1, chi, chi))
+    m1m0 = np.reshape(prod.transpose((1, 0, 2, 3)), (-1, chi, chi))
+    all_coms = m0m1 - m1m0
+
+    # project commutators on basis of g
+    # vectorized computation to obtain coefficients in decomposition:
+    # v = ∑ (tr(v @ e_j) / ||e_j||^2) * e_j
+    gram_inv = np.linalg.pinv(np.tensordot(g, g, axes=[[1, 2], [2, 1]])).real
+    adj = gram_inv @ np.tensordot(g, all_coms, axes=[[1, 2], [-1, -2]]).imag
+    adj = -np.reshape(adj, (dimg, dimg, dimg))
+    return adj

pennylane/labs/tests/lie/test_structure_constants.py

@@ -0,0 +1,80 @@
+# Copyright 2024 Xanadu Quantum Technologies Inc.
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Tests for pennylane/labs/lie/structure_constants.py functionality"""
+# pylint: disable=no-self-use
+
+import numpy as np
+import pytest
+
+import pennylane as qml
+from pennylane.labs.lie import structure_constants_dense
+from pennylane.pauli import PauliSentence, PauliWord
+
+## Construct some example DLAs
+# TFIM
+gens = [PauliSentence({PauliWord({i: "X", i + 1: "X"}): 1.0}) for i in range(2)]
+gens += [PauliSentence({PauliWord({i: "Z"}): 1.0}) for i in range(3)]
+Ising3 = qml.pauli.lie_closure(gens, pauli=True)
+
+# XXZ-type DLA, i.e. with true PauliSentences
+gens2 = [
+    PauliSentence(
+        {
+            PauliWord({i: "X", i + 1: "X"}): 1.0,
+            PauliWord({i: "Y", i + 1: "Y"}): 1.0,
+        }
+    )
+    for i in range(2)
+]
+gens2 += [PauliSentence({PauliWord({i: "Z"}): 1.0}) for i in range(3)]
+XXZ3 = qml.pauli.lie_closure(gens2, pauli=True)
+
+
+class TestAdjointRepr:
+    """Tests for structure_constants"""
+
+    def test_structure_constants_dim(self):
+        """Test the dimension of the adjoint repr"""
+        d = len(Ising3)
+        Ising3_dense = np.array([qml.matrix(op, wire_order=range(3)) for op in Ising3])
+        adjoint = structure_constants_dense(Ising3_dense)
+        assert adjoint.shape == (d, d, d)
+        assert adjoint.dtype == float
+
+    @pytest.mark.parametrize("dla", [Ising3, XXZ3])
+    def test_structure_constants_elements(self, dla):
+        r"""Test relation :math:`[i G_\alpha, i G_\beta] = \sum_{\gamma = 0}^{\mathfrak{d}-1} f^\gamma_{\alpha, \beta} iG_\gamma`."""
+
+        d = len(dla)
+        dla_dense = np.array([qml.matrix(op, wire_order=range(3)) for op in dla])
+        ad_rep = structure_constants_dense(dla_dense)
+        for i in range(d):
+            for j in range(d):
+
+                comm_res = 1j * dla[i].commutator(dla[j])
+                res = sum(
+                    np.array(c, dtype=complex) * dla[gamma]
+                    for gamma, c in enumerate(ad_rep[:, i, j])
+                )
+                res.simplify()
+                assert comm_res == res
+
+    @pytest.mark.parametrize("dla", [Ising3, XXZ3])
+    def test_use_operators(self, dla):
+        """Test that operators can be passed and lead to the same result"""
+        ad_rep_true = qml.pauli.dla.structure_constants(dla)
+
+        ops = np.array([qml.matrix(op.operation(), wire_order=range(3)) for op in dla])
+        ad_rep = structure_constants_dense(ops)
+        assert qml.math.allclose(ad_rep, ad_rep_true)