Introducing (dynamical) Lie algebras for quantum practitioners¶

Introduction¶

Lie algebras, pronounced like the name “Lee”, offer a fresh perspective on some of the established ideas in quantum physics and become more and more important in quantum computing. Let us recap some of the key concepts of quantum mechanics and how they relate to and give rise to Lie algebras.

Most physicists know quantum physics in terms of wavefunctions $|\psi\rangle$ that live in a Hilbert space $\mathcal{H},$ as well as (bounded) linear operators $\hat{O}$ that live in the space of linear operators on that Hilbert space, $\mathcal{L}(\mathcal{H}).$ For finite dimensional systems (think, $n$ number of qubits) we have complex valued state vectors (wavefunctions) in $\mathcal{H} = \mathbb{C}^{2^n}$ with norm 1 and square matrices (linear operators) in $\mathcal{L}(\mathcal{H}) = \mathbb{C}^{2^n \times 2^n}.$

Two very important sub-classes of linear operators in quantum mechanics are unitary and Hermitian operators. Hermitian operators $H$ are self-adjoint, $H^\dagger = H,$ and describe observables that can be measured. Unitary operators are norm-preserving such that $\langle \psi | U^\dagger U | \psi \rangle = \langle \psi | \psi \rangle,$ in particular we have $U^{-1} = U^\dagger.$ They describe how quantum states are transformed and ensure that their norm is preserved.

A unitary operator can always be written as

where we say that $H$ is the generator of $U.$ Take for example a single qubit rotation $U(\phi) = e^{-i \frac{\phi}{2} X}.$ $U(\phi)$ is the unitary evolution that rotates a quantum state in Hilbert space around the x-axis on the Bloch sphere, and is generated by the Pauli $X$ matrix.

The space of all such unitary operators forms the so-called special unitary group $SU(N),$ where for qubit systems we have $N=2^n$ with $N$ the dimension of the group and n the number of qubits. In quantum computing, we are typically dealing with the Hilbert space $\mathcal{H} = \mathbb{C}^{2^n}$ and for full universality we require the available gates to span all of $SU(2^n).$ That means when we have all unitaries of $SU(2^n)$ available to us, we can reach any state in Hilbert space from any other state.

The Lie group $SU(2^n)$ has an associated Lie algebra to it, called $\mathfrak{su}(2^n)$ (more on that later). In some cases, it is more convenient to work with the associated Lie algebra rather than the Lie group.

So if you are familiar with quantum computing but knew nothing about Lie algebras and Lie groups before this demo, the good news is that you actually already know the elements of both. Roughly speaking, the relevant Lie group in quantum computing is the space of unitaries, and the relevant Lie algebra is the space of Hermitian matrices. Further, they are related to each other: The Lie algebra (Hermitian matrices) generates the Lie group (unitaries) via the exponential map. There are, however, some subtleties if we want to be mathematically precise, as we will explore more in depth now.

Lie algebras¶

After some motivation and connections to concepts we are already familiar with, let us formally introduce Lie algebras. An algebra is a vector space equipped with a bilinear operation. A Lie algebra $\mathfrak{g}$ is a special case where the bilinear operation behaves like a commutator. In particular, the bilinear operation $[\bullet, \bullet]: \mathfrak{g} \times \mathfrak{g} \rightarrow \mathfrak{g}$ needs to satisfy

• $[x, x] = 0 \ \forall x \in \mathfrak{g}$ (alternativity)

• $[x, [y, z]] + [y, [z, x]] + [z, [x, y]] = 0 \ \forall x,y,z \in \mathfrak{g}$ (Jacobi identity)

• $[x, y] = - [y, x] \ \forall x,y \in \mathfrak{g}$ (anti-commutativity)

The last one, anti-commutativity, technically is not an axiom but follows from bilinearity and alternativity, but is so crucial that it is worth highlighting. These properties generally define the so-called Lie bracket, where the commutator is just one special case thereof. A different example would be the cross-product between vectors in $\mathbb{R}^3.$ Note also that we are talking about a vector space in the mathematical sense, and the elements (“vectors”) in $\mathfrak{g}$ are actually operators (matrices) in our case looking at quantum physics.

One very relevant Lie algebra for us is the special unitary algebra $\mathfrak{su}(N),$ the space of $N \times N$ skew-Hermitian matrices with trace zero. The fact that we look at skew-Hermitian ($H^\dagger = - H$) instead of Hermitian ($H^\dagger = H$) matrices is a technical detail (see note below). For all practical purposes you can just think of Hermitian operators with an imaginary factor and note that linear combinations are strictly over the reals. In fact, you may sometimes find references to $\mathfrak{su}(N)$ being the Hermitian matrices in physics literature (see Wikipedia).

The Pauli matrices $\{iX, iY, iZ\}$ span the $\mathfrak{su}(2)$ algebra that we can associate with single qubit dynamics. For multiple qubits we have

where the span is over the reals $\mathbb{R}.$ In particular, we cannot do a complex span over Paulis, since this could destroy the anti-commutativity again. Another way of thinking about this is that Lie algebra elements “live” in the exponent of a unitary operator, and having that exponent become Hermitian instead of skew-Hermitian destroys the unitary property.

Let us briefly test some of these properties numerically. First, let us do a linear combination of $\{iX, iY, iZ\}$ with some real values and check unitarity after putting them in the exponent.

import numpy as np
import pennylane as qml
from pennylane import X, Y, Z

su2 = [1j * X(0), 1j * Y(0), 1j * Z(0)]

coeffs = [1., 2., 3.]                           # some real coefficients
exponent = qml.dot(coeffs, su2)                 # linear combination of operators
U = qml.math.expm(exponent.matrix())            # compute matrix exponent of lin. comb.
print(np.allclose(U.conj().T @ U, np.eye(2)))   # check that result is unitary UU* = 1

True

If we throw complex values in the mix, the resulting matrix is not unitary anymore.

coeffs = [1., 2.+ 1j, 3.]                       # some complex coefficients
exponent = qml.dot(coeffs, su2)
U = qml.math.expm(exponent.matrix())
print(np.allclose(U.conj().T @ U, np.eye(2)))   # result is not unitary anymore

False

Relation to Lie groups¶

We said earlier that the Lie group $SU(N)$ is generated by the Lie algebra $\mathfrak{su}(N).$ But what do we actually mean by that? Essentially, for every unitary matrix $U \in SU(N)$ there is a (real) linear combination of elements $iP_j \in \mathfrak{su}(N)$ such that

for some real coefficients $\lambda_j \in \mathbb{R}.$

In quantum computing, we are interested in unitary gates that, when composed together, realize a complicated unitary evolution $U.$ That could, for example, be a unitary that prepares the ground state of a Hamiltonian from the $|0\rangle^{\otimes n}$ state or perform a sub-routine like the quantum Fourier transform. In particular, we are not composing quantum circuits via creating superpositions of Lie algebra elements as is done in the last equation.

Luckily, beyond the relation above, we also know that any unitary matrix $U \in SU(2^n)$ can be decomposed in a finite product of elements from a universal gate set $\mathcal{U},$

for $U_j \in \mathcal{U}.$ A universal gate set is formed exactly when the generators of its elements form $\mathfrak{su}(2^n).$ Note that in this equation the product may feature a large number of gates $U_j,$ so universality does not guarantee an efficient decomposition but rather just a finite one.

print(qml.commutator(1j * X(0), 1j * Y(0)))

-2j * Z(0)

list_ops = [1j * X(0), 1j * Y(0), 1j * Z(0)]
for op1 in list_ops:
    for op2 in list_ops:
        print(qml.commutator(op1, op2))

0 * I()
-2j * Z(0)
2j * Y(0)
2j * Z(0)
0 * I()
-2j * X(0)
-2j * Y(0)
2j * X(0)
0 * I()

dla = qml.lie_closure([X(0), Y(0)])
dla

[X(0), Y(0), Z(0)]

U_target = qml.matrix(qml.RZ(-0.5, 0))
decomp = qml.ops.one_qubit_decomposition(U_target, 0, rotations="XYX")
print(decomp)

[RX(1.5707963267948966, wires=[0]), RY(0.5000000000000004, wires=[0]), RX(10.995574287564276, wires=[0])]

U = qml.prod(*decomp).matrix()
print(1 - np.real(np.trace(U_target @ U))/2)

0.0

generators = [1j * (X(0) @ X(1)), 1j * Z(0), 1j * Z(1)]

# collection of linearly independent basis vectors, automatically discards linearly dependent ones
dla = qml.pauli.PauliVSpace(generators, dtype=complex)
for i, op1 in enumerate(generators):
    for op2 in generators[i+1:]:
        res = qml.commutator(op1, op2)/2
        res = res.simplify() # ensures all products of scalars are executed
        print(f"[{op1}, {op2}] = {res}")

        if res.scalar != 0. and dla.is_independent(res.pauli_rep):
            # Note that the previous is_independent check is just for pedagocical purposes
            # as dla.add already checks linear independence below
            print(f"Appending {res}")
            dla.add(res)

[1j * (X(0) @ X(1)), 1j * Z(0)] = 1j * (Y(0) @ X(1))
Appending 1j * (Y(0) @ X(1))
[1j * (X(0) @ X(1)), 1j * Z(1)] = 1j * (X(0) @ Y(1))
Appending 1j * (X(0) @ Y(1))
[1j * Z(0), 1j * Z(1)] = 0 * I()

for i, op1 in enumerate(dla.basis.copy()):
    for op2 in dla.basis.copy()[i+1:]:
        res = qml.commutator(op1, op2)/2
        res = res.simplify()
        print(f"[{op1}, {op2}] = {res}")

        if res.scalar != 0. and dla.is_independent(res.pauli_rep):
            print(f"Appending {res}")
            dla.add(res)

[1j * X(0) @ X(1), 1j * Z(0)] = 1j * (Y(0) @ X(1))
[1j * X(0) @ X(1), 1j * Z(1)] = 1j * (X(0) @ Y(1))
[1j * X(0) @ X(1), 1j * Y(0) @ X(1)] = -1j * Z(0)
[1j * X(0) @ X(1), 1j * X(0) @ Y(1)] = -1j * Z(1)
[1j * Z(0), 1j * Z(1)] = 0 * I()
[1j * Z(0), 1j * Y(0) @ X(1)] = 1j * (X(0) @ X(1))
[1j * Z(0), 1j * X(0) @ Y(1)] = -1j * (Y(0) @ Y(1))
Appending -1j * (Y(0) @ Y(1))
[1j * Z(1), 1j * Y(0) @ X(1)] = -1j * (Y(0) @ Y(1))
[1j * Z(1), 1j * X(0) @ Y(1)] = 1j * (X(0) @ X(1))
[1j * Z(1), -1j * Y(0) @ Y(1)] = -1j * (Y(0) @ X(1))
[1j * Y(0) @ X(1), 1j * X(0) @ Y(1)] = 0 * I()
[1j * Y(0) @ X(1), -1j * Y(0) @ Y(1)] = 1j * Z(1)
[1j * X(0) @ Y(1), -1j * Y(0) @ Y(1)] = 1j * Z(0)

for op in dla.basis:
    print(op)

1j * X(0) @ X(1)
1j * Z(0)
1j * Z(1)
1j * Y(0) @ X(1)
1j * X(0) @ Y(1)
-1j * Y(0) @ Y(1)

dla2 = qml.lie_closure([X(0) @ X(1), Z(0), Z(1)])
for op in dla2:
    print(op)

X(0) @ X(1)
Z(0)
Z(1)
-1.0 * (Y(0) @ X(1))
-1.0 * (X(0) @ Y(1))
Y(0) @ Y(1)

def IsingGenerators(n, bc="open"):
    gens = [X(i) @ X(i+1) for i in range(n-1)]
    gens += [Z(i) for i in range(n)]
    if bc == "periodic":
        gens += [X(n-1) @ X(0)]
    return gens

for n in range(2, 5):
    open_ = qml.lie_closure(IsingGenerators(n, "open"))
    periodic_ = qml.lie_closure(IsingGenerators(n, "periodic"))
    print(f"Ising for n = {n}")
    print(f"open: {len(open_)} = {n*(2*n-1)} = 2n * (2n - 1)/2")
    print(f"open: {len(periodic_)} = {2*n*(2*n-1)} = 2 * 2n * (2n - 1)/2")

Ising for n = 2
open: 6 = 6 = 2n * (2n - 1)/2
open: 6 = 12 = 2 * 2n * (2n - 1)/2
Ising for n = 3
open: 15 = 15 = 2n * (2n - 1)/2
open: 30 = 30 = 2 * 2n * (2n - 1)/2
Ising for n = 4
open: 28 = 28 = 2n * (2n - 1)/2
open: 56 = 56 = 2 * 2n * (2n - 1)/2

Hamiltonian Symmetries¶

With this new knowledge we are now able to understand what is meant when some Hamiltonian models are said to be symmetric under some symmetry group. Specifically, let us look at the spin-1/2 Heisenberg model Hamiltonian in 1D with nearest neighbor interactions,

with some coupling constants $J_j \in \mathbb{R}.$ First it is important to understand that the generators here are made up of the whole sum of operators $X_j X_{j+1} + Y_j Y_{j+1} + Z_j Z_{j+1}$, and not each individual term $X_j X_{j+1}$, $Y_j Y_{j+1},$ and $Z_j Z_{j+1}.$ This Hamiltonian is said to be $SU(2)$ invariant, but what does that mean?

First, let us identify total spin components

Together, they span a representation of $\mathfrak{su}(2)$ (more on that below). These total spin components each commute with the system Hamiltonian, i.e.

Let us briefly verify this for a small example for n = 3 qubits that readily generalizes to arbitrary sizes.

n = 3
H = qml.sum(*(P(i) @ P(i+1) for i in range(n-1) for P in [X, Y, Z]))

SX = qml.sum(*(X(i) for i in range(n)))
SY = qml.sum(*(Y(i) for i in range(n)))
SZ = qml.sum(*(Z(i) for i in range(n)))

print(qml.commutator(H, SX))
print(qml.commutator(H, SY))
print(qml.commutator(H, SZ))

0j * (Z(0) @ Y(1)) + 0j * (Y(0) @ Z(1)) + 0j * (Z(1) @ Y(2)) + 0j * (Y(1) @ Z(2))
0j * (Z(0) @ X(1)) + 0j * (X(0) @ Z(1)) + 0j * (Z(1) @ X(2)) + 0j * (X(1) @ Z(2))
0j * (Y(0) @ X(1)) + 0j * (X(0) @ Y(1)) + 0j * (Y(1) @ X(2)) + 0j * (X(1) @ Y(2))

Now that we know that the Heisenberg model Hamiltonian commutes with any $S_\text{tot}^{\alpha}$ for $\alpha \in \{x, y, z\},$ we also know that any observable composed of the total spin components

with arbitrary real coefficients $c_x, c_y, c_z \in \mathbb{R}$ commutes with the Hamiltonian,

An immediate consequence of this is that also $[e^{-i\hat{O}}, H_\text{Heis}] = 0.$ Hence, $H_\text{Heis}$ is invariant under any action of $e^{-i \hat{O}} \in SU(2),$

Thus, $H_\text{Heis}$ is said to be $SU(2)$ symmetric.

There are several things to note: We have so far been sloppy in equating Lie algebras with one of many possible representations (e.g. $\text{span}_{\mathbb{R}} \{iX, iY, iZ\} = \mathfrak{su}(2)$ above). The total spin component operators $S_\text{tot}^{x}, S_\text{tot}^{y}, S_\text{tot}^{z}$ span another representation of $\mathfrak{su}(2)$ and, therefore, generate $SU(2).$ This is easily verified by looking at the commutation relation between these operators that match $[\hat{O}_i, \hat{O}_j] = 2i \varepsilon_{ij\ell} \hat{O}_\ell,$ the defining property of $\mathfrak{su}(2).$

print(qml.commutator(SX, SY) == (2j*SZ).simplify())
print(qml.commutator(SZ, SX) == (2j*SY).simplify())
print(qml.commutator(SY, SZ) == (2j*SX).simplify())

True
True
True

Another perspective on the inherent $SU(2)$ symmetry of $H_\text{Heis}$ is that the expectation value of $\hat{O}$ with respect to any state $|\psi\rangle$ is invariant under evolution of $H_\text{Heis}.$ This can be seen by looking at

where $|\psi(t)\rangle = e^{-i t H_\text{Heis}} |\psi\rangle$ is the evolved state under $H_\text{Heis}.$ In that sense, $\hat{O}$ is a conserved quantity of the system. One often associates a so-called quantum number with each generator of the symmetry, here $\{S_\text{tot}^{x}, S_\text{tot}^{y}, S_\text{tot}^{z}\},$ the total spin numbers.

Overall, we saw that $H_\text{Heis}$ is invariant under action of $SU(2)$ and how this gives rise to conserved quantities.

Conclusion¶

With this introduction, we hope to clarify some terminology, introduce the basic concepts of Lie theory and motivate their relevance in quantum physics by touching on universality and symmetries. While Lie theory and symmetries are playing a central role in established fields such as quantum phase transitions (see note above) and high energy physics, they have recently also emerged in quantum machine learning with the onset of geometric quantum machine learning 2 3 (see our recent introduction to geometric quantum machine learning). Further, DLAs have recently become instrumental in classifying criteria for barren plateaus 4 5 and designing simulators based on them 6.

References¶

1

Roeland Wiersema, Efekan Kökcü, Alexander F. Kemper, Bojko N. Bakalov “Classification of dynamical Lie algebras for translation-invariant 2-local spin systems in one dimension” arXiv:2309.05690, 2023.

2

Johannes Jakob Meyer, Marian Mularski, Elies Gil-Fuster, Antonio Anna Mele, Francesco Arzani, Alissa Wilms, Jens Eisert “Exploiting symmetry in variational quantum machine learning” arXiv:2205.06217, 2022.

3

Quynh T. Nguyen, Louis Schatzki, Paolo Braccia, Michael Ragone, Patrick J. Coles, Frederic Sauvage, Martin Larocca, M. Cerezo “Theory for Equivariant Quantum Neural Networks” arXiv:2210.08566, 2022.

4

Enrico Fontana, Dylan Herman, Shouvanik Chakrabarti, Niraj Kumar, Romina Yalovetzky, Jamie Heredge, Shree Hari Sureshbabu, Marco Pistoia “The Adjoint Is All You Need: Characterizing Barren Plateaus in Quantum Ansätze” arXiv:2309.07902, 2023.

5

Michael Ragone, Bojko N. Bakalov, Frédéric Sauvage, Alexander F. Kemper, Carlos Ortiz Marrero, Martin Larocca, M. Cerezo “A Unified Theory of Barren Plateaus for Deep Parametrized Quantum Circuits” arXiv:2309.09342, 2023.

6(1,2)

Matthew L. Goh, Martin Larocca, Lukasz Cincio, M. Cerezo, Frédéric Sauvage “Lie-algebraic classical simulations for variational quantum computing” arXiv:2308.01432, 2023.

7

Rolando D. Somma “Quantum Computation, Complexity, and Many-Body Physics” arXiv:quant-ph/0512209, 2005.

About the author¶

Total running time of the script: (0 minutes 0.047 seconds)