[DLA 4] qml.dla.center function

doc/code/qml_dla.rst

@@ -0,0 +1,13 @@
+qml.dla
+=======
+
+(Dynamical) Lie Algebra functionality in PennyLane
+
+See our `introduction to Dynamical Lie Algebras for quantum practitioners <https://pennylane.ai/qml/demos/tutorial_liealgebra/>`__.
+
+.. currentmodule:: pennylane.dla
+
+.. automodapi:: pennylane.dla
+    :no-heading:
+    :no-main-docstr:
+    :no-inherited-members:

doc/index.rst

@@ -188,6 +188,7 @@ PennyLane is **free** and **open source**, released under the Apache License, Ve
    code/qml
    code/qml_compiler
    code/qml_data
+   code/qml_dla
    code/qml_drawer
    code/qml_fermi
    code/qml_fourier

doc/releases/changelog-dev.md

@@ -64,6 +64,74 @@
 * Added new function `qml.operation.convert_to_legacy_H` to convert `Sum`, `SProd`, and `Prod` to `Hamiltonian` instances.
   [(#5309)](https://github.com/PennyLaneAI/pennylane/pull/5309)
 
+<h4>Dynamical Lie Algebra functionality</h4>
+
+* A new `qml.dla.lie_closure` function to compute the Lie closure of a list of operators.
+  [(#5161)](https://github.com/PennyLaneAI/pennylane/pull/5161)
+  [(#5169)](https://github.com/PennyLaneAI/pennylane/pull/5169)
+
+  The Lie closure, pronounced "Lee closure", is a way to compute the so-called dynamical Lie algebra (DLA) of a set of operators.
+  For a list of operators `ops = [op1, op2, op3, ..]`, one computes all nested commutators between `ops` until no new operators are generated from commutation.
+  All these operators together form the DLA, see e.g. section IIB of [arXiv:2308.01432](https://arxiv.org/abs/2308.01432).
+
+  Take for example the following ops
+
+  ```python
+  ops = [X(0) @ X(1), Z(0), Z(1)]
+  ```
+
+  A first round of commutators between all elements yields the new operators `Y(0) @ X(1)` and `X(0) @ Y(1)` (omitting scalar prefactors).
+
+  ```python
+  >>> qml.commutator(X(0) @ X(1), Z(0))
+  -2j * (X(1) @ Y(0))
+  >>> qml.commutator(X(0) @ X(1), Z(1))
+  -2j * (Y(1) @ X(0))
+  ```
+
+  A next round of commutators between all elements further yields the new operator `Y(0) @ Y(1)`.
+
+  ```python
+  >>> qml.commutator(X(0) @ Y(1), Z(0))
+  -2j * (Y(1) @ Y(0))
+  ```
+
+  After that, no new operators emerge from taking nested commutators and we have the resulting DLA.
+  This can now be done in short via `qml.dla.lie_closure` as follows.
+
+  ```python
+  >>> ops = [X(0) @ X(1), Z(0), Z(1)]
+  >>> dla = qml.dla.lie_closure(ops)
+  >>> print(dla)
+  [1.0 * X(1) @ X(0),
+   1.0 * Z(0),
+   1.0 * Z(1),
+   -1.0 * X(1) @ Y(0),
+   -1.0 * Y(1) @ X(0),
+   -1.0 * Y(1) @ Y(0)]
+  ```
+
+* We can compute the adjoint representation of a dynamical Lie algebra.
+  [(5406)](https://github.com/PennyLaneAI/pennylane/pull/5406)
+
+  For example, we can compute the adjoint representation of the transverse field Ising model DLA.
+
+  >>> dla = [1.0 * X(0) @ X(1), 1.0 * Z(0), 1.0 * Z(1), -1.0 * Y(0) @ X(1), -1.0 * X(0) @ Y(1), -1.0 * Y(0) @ Y(1)]
+  >>> adjoint_rep = qml.dla.adjoint_repr(dla)
+  >>> adjoint_rep.shape
+  (6, 6, 6)
+
+* We can compute the center of a dynamical Lie algebra.
+  [(#5477)](https://github.com/PennyLaneAI/pennylane/pull/5477)
+
+  Given a DLA `g`, we can now compute its center. The `center` is the collection of operators that commute with _all_ other operators in the DLA.
+
+  ```pycon
+  >>> g = [X(0), X(1) @ X(0), Y(1), Z(1) @ X(0)]
+  >>> center(g)
+  [X(0)]
+  ```
+
 <h3>Improvements 🛠</h3>
 
 * Improve the performance of computing the matrix of `qml.QFT`
@@ -151,14 +219,6 @@
   SpectralNormError(6.166666666666668e-06)
   ```
 
-<h3>Improvements 🛠</h3>
-
-* The `qml.is_commuting` function now accepts `Sum`, `SProd`, and `Prod` instances.
-  [(#5351)](https://github.com/PennyLaneAI/pennylane/pull/5351)
-
-* Operators can now be left multiplied `x * op` by numpy arrays.
-  [(#5361)](https://github.com/PennyLaneAI/pennylane/pull/5361)
-
 * The `molecular_hamiltonian` function calls `PySCF` directly when `method='pyscf'` is selected.
   [(#5118)](https://github.com/PennyLaneAI/pennylane/pull/5118)
 

pennylane/__init__.py

@@ -32,6 +32,7 @@
 import pennylane.qnn
 import pennylane.templates
 import pennylane.pauli
+import pennylane.dla
 from pennylane.pauli import pauli_decompose
 from pennylane.resource import specs
 import pennylane.resource

pennylane/dla/__init__.py

@@ -0,0 +1,18 @@
+# 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.
+"""(Dynamical) Lie Algebra functionality in PennyLane"""
+
+from .lie_closure import lie_closure
+from .structure_constants import structure_constants
+from .center import center

pennylane/dla/center.py

@@ -0,0 +1,77 @@
+# 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 center of a Lie algebra"""
+from typing import List, Union
+from itertools import combinations
+
+import numpy as np
+
+from pennylane.pauli import PauliSentence, PauliWord
+from pennylane.operation import Operator
+
+
+def center(
+    g: List[Union[Operator, PauliWord, PauliSentence]], pauli: bool = False
+) -> List[Union[Operator, PauliSentence]]:
+    r"""
+    A function to compute the center of a Lie algebra.
+
+    Given a Lie algebra :math:`\mathfrak{g} = \{h_1,.., h_d\}`, the center :math:`\mathfrak{\xi}(\mathfrak{g})`
+    is given by all elements in :math:`\mathfrak{g}` that commute with `all` other elements in :math:`\mathfrak{g}`,
+
+    .. math:: \mathfrak{\xi}(\mathfrak{g}) := \{h \in \mathfrak{g} | [h, h_i]=0 \ \forall h_i \in \mathfrak{g} \}
+
+    Args:
+        g (List[Union[Operator, PauliSentence]]): List of operators for which to find the center.
+        pauli (bool): Indicates whether it is assumed that :class:`~PauliSentence` instances are input and returned.
+            This can help with performance to avoid unnecessary conversions from :class:`~PauliSentence` to :class:`~Operator`
+            or :class:`~PauliWord` and vice versa. Note that the input in that case also has to be a list of :class:`~PauliSentence` instances.
+            Default is ``False``.
+
+    Returns:
+        List[Union[Operator, PauliSentence]]: Center of ``g``
+
+    **Example**
+
+    We can compute the center of a DLA ``g``. For that, we compute the DLA via :func:`~lie_closure`.
+
+    >>> generators = [qml.X(0), qml.X(0) @ qml.X(1), qml.Y(1)]
+    >>> g = qml.dla.lie_closure(generators)
+
+    The ``center`` is then the collection of operators that commute with `all` other operators in the DLA.
+    In this case, just ``X(0)``.
+
+    >>> center(g)
+    [X(0)]
+
+    """
+
+    if not pauli:
+        g = [o.pauli_rep for o in g]
+
+    d = len(g)
+    commutators = np.zeros((d, d), dtype=int)
+    for (j, op1), (k, op2) in combinations(enumerate(g), r=2):
+        res = op1.commutator(op2)
+        res.simplify()
+        if res != PauliSentence({}):
+            commutators[j, k] = 1  # dummy value to indicate operators dont commute
+            commutators[k, j] = 1
+
+    mask = np.all(commutators == 0, axis=0)
+    res = list(np.array(g)[mask])
+
+    if not pauli:
+        res = [op.operation() for op in res]
+    return res