The KAK decomposition¶

Lie algebras¶

As mentioned above, we will assume a basic understanding of the mathematical objects we will use. To warm up, however, let us briefly talk about Lie algebras (for details see our intro to (dynamical) Lie algebras).

A Lie algebra $\mathfrak{g}$ is a vector space with an additional operation that takes two vectors to a new vector, the Lie bracket. To form an algebra, $\mathfrak{g}$ must be closed under the Lie bracket. For our purposes, the vectors will always be matrices and the Lie bracket will be the matrix commutator.

Example

Our working example in this demo will be the special unitary algebra in two dimensions, $\mathfrak{su}(2).$ It consists of traceless complex-valued skew-Hermitian $2\times 2$ matrices, which we can conveniently describe using the Pauli matrices:

We will also look at a more involved example at the end of the demo.

Let us set up $\mathfrak{su}(2)$ in code. Note that the algebra itself consists of skew-Hermitian matrices, but we will work with the Hermitian counterparts as inputs, i.e., we will skip the factor $i.$ We can check that $\mathfrak{su}(2)$ is closed under commutators by computing all nested commutators, the so-called Lie closure, and observing that the closure is not larger than $\mathfrak{su}(2)$ itself. Of course, we could also check the closure manually for this small example.

from itertools import product, combinations
import pennylane as qml
from pennylane import X, Y, Z
import numpy as np

su2 = [X(0), Y(0), Z(0)]
print(f"su(2) is {len(su2)}-dimensional")

all_hermitian = all(qml.equal(qml.adjoint(op).simplify(), op) for op in su2)
print(f"The operators are all Hermitian: {all_hermitian}")

su2_lie_closed = qml.lie_closure(su2)
print(f"The Lie closure of su(2) is {len(su2_lie_closed)}-dimensional.")

traces = [op.pauli_rep.trace() for op in su2]
print(f"All operators are traceless: {np.allclose(traces, 0.)}")

su(2) is 3-dimensional
The operators are all Hermitian: True
The Lie closure of su(2) is 3-dimensional.
All operators are traceless: True

We find that $\mathfrak{su}(2)$ is indeed closed, and that it is a 3-dimensional space, as expected from the explicit expression above. We also picked a correct representation with traceless operators.

Lie group from a Lie algebra¶

The topic of Lie groups and Lie algebras is a large field of study and there are many things we could talk about in this section. For the sake of brevity, however, we will only list a few important properties that are needed further below. For more details and proofs, refer to your favourite Lie theory book, which could be 1 or 2.

The Lie group $\mathcal{G}$ associated to a Lie algebra $\mathfrak{g}$ is given by the exponential map applied to the algebra:

We will only consider Lie groups $\exp(\mathfrak{g})$ arising from a Lie algebra $\mathfrak{g}$ here. As we usually think about the unitary algebras $\mathfrak{u}$ and their subalgebras, the correspondence is well-known to quantum practitioners: Exponentiate a skew-Hermitian matrix to obtain a unitary operation, i.e., a quantum gate.

Interaction between Lie groups and algebras¶

We will make use of a particular interaction between the algebra $\mathfrak{g}$ and its group $\mathcal{G},$ called the adjoint action of $\mathcal{G}$ on $\mathfrak{g}.$ It is given by

Similarly, we can interpret the Lie bracket as a map of $\mathfrak{g}$ acting on itself, which is called the adjoint representation of $\mathfrak{g}$ on itself:

The adjoint group action and adjoint algebra representation do not only carry a very similar name, they are intimately related:

where we applied the exponential map to $\text{ad}_x,$ which maps from $\mathfrak{g}$ to itself, via its series representation. We will refer to this relationship as the adjoint identity. We talk about $\text{Ad}$ and $\text{ad}$ in more detail in the box below, and refer to our demo g-sim: Lie algebraic classical simulations for further discussion.

Subalgebras and Cartan decompositions¶

A subalgebra $\mathfrak{k}$ of a Lie algebra $\mathfrak{g}$ is a vector subspace that is closed under the Lie bracket. Overall, this means that $\mathfrak{k}$ is closed under addition, scalar multiplication, and the Lie bracket. The latter often is simply written as $[\mathfrak{k}, \mathfrak{k}]\subset \mathfrak{k}.$

The algebras we are interested in come with an inner product between its elements. For our purposes, it is sufficient to assume that it is

Let’s implement the inner product and an orthogonality check based on it:

def inner_product(op1, op2):
    """Compute the trace inner product between two operators."""
    # Use two wires to reuse it in the second example on two qubits later on
    return qml.math.trace(qml.matrix(qml.adjoint(op1) @ op2, wire_order=[0, 1]))


def is_orthogonal(op, basis):
    """Check whether an operator is orthogonal to a space given by some basis."""
    return np.allclose([inner_product(op, basis_op) for basis_op in basis], 0)

Given a subalgebra $\mathfrak{k}\subset \mathfrak{g},$ the inner product allows us to define an orthogonal complement

In this context, $\mathfrak{k}$ is commonly called the vertical space, $\mathfrak{p}$ accordingly is the horizontal space. The KAK decomposition will apply to scenarios in which these spaces satisfy additional commutation relations, which do not hold for all subalgebras:

The first property tells us that $\mathfrak{p}$ is left intact by the adjoint action of $\mathfrak{k}.$ The second property suggests that $\mathfrak{p}$ behaves like the opposite of a subalgebra, i.e., all commutators lie in its complement, the subalgebra $\mathfrak{k}.$ Due to the adjoint identity from above, the first property also holds for group elements acting on algebra elements; for all $x\in\mathfrak{p}$ and $K\in\mathcal{K}=\exp(\mathfrak{k}),$ we have

If the reductive property holds, the quotient space $\mathcal{G}/\mathcal{K}$ of the groups of $\mathfrak{g}$ and $\mathfrak{k}$ (see detail box below) is called a reductive homogeneous space. If both properties hold, $(\mathfrak{k}, \mathfrak{p})$ is called a Cartan pair and we call $\mathfrak{g}=\mathfrak{k} \oplus \mathfrak{p}$ a Cartan decomposition. $(\mathfrak{g}, \mathfrak{k})$ is named a symmetric pair and the quotient $\mathcal{G}/\mathcal{K}$ is a symmetric space. Symmetric spaces are relevant for a wide range of applications in physics and have been studied a lot throughout the last hundred years.

Example

For our example, we consider the subalgebra $\mathfrak{k}=\mathfrak{u}(1)$ of $\mathfrak{su}(2)$ that generates Pauli-$Z$ rotations:

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 check_cartan_decomp().

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. Similar to qml.liealg.check_cartan_decomp"""
    # Check Lie closure of 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}.")

    # Orthogonal complement of k, assuming that everything is given in the same basis.
    p = [g_op for g_op in g if is_orthogonal(g_op, k)]
    print(
        f"k has dimension {len(k)}, p has dimension {len(p)}, which combine to "
        f"the dimension {len(g)} of g: {len(k)+len(p)==len(g)}"
    )

    # Check reductive property
    k_p_commutators = [qml.commutator(k_op, p_op) for k_op, p_op in product(k, p)]
    k_p_coms_in_p = all([is_orthogonal(com, k) for com in k_p_commutators])

    print(f"All commutators in [k, p] are in p (orthogonal to k): {k_p_coms_in_p}.")
    if k_p_coms_in_p:
        print(f"{space_name} is a reductive homogeneous space.")

    # Check symmetric property
    p_p_commutators = [qml.commutator(*ops) for ops in combinations(p, r=2)]
    p_p_coms_in_k = all([is_orthogonal(com, p) for com in p_p_commutators])

    print(f"All commutators in [p, p] are in k (orthogonal to p): {p_p_coms_in_k}.")
    if p_p_coms_in_k:
        print(f"{space_name} is a symmetric space.")

    return p


u1 = [Z(0)]
space_name = "SU(2)/U(1)"
p = check_cartan_decomp(su2, u1, space_name)

The Lie closure of k is as big as k itself: True.
k has dimension 1, p has dimension 2, which combine to the dimension 3 of g: True
All commutators in [k, p] are in p (orthogonal to k): True.
SU(2)/U(1) is a reductive homogeneous space.
All commutators in [p, p] are in k (orthogonal to p): True.
SU(2)/U(1) is a symmetric space.

Cartan subalgebras¶

The symmetric property of a Cartan decomposition $([\mathfrak{p}, \mathfrak{p}]\subset\mathfrak{k})$ tells us that $\mathfrak{p}$ is very far from being a subalgebra (commutators never end up in $\mathfrak{p}$ again). This also gives us information about potential subalgebras within $\ \mathfrak{p}.$ Assume we have a subalgebra $\mathfrak{a}\subset\mathfrak{p}.$ Then the commutator between any two elements $x, y\in\mathfrak{a}$ must satisfy

That is, the commutator must lie in both orthogonal complements $\mathfrak{k}$ and $\mathfrak{p},$ which only have the zero vector in common. This tells us that all commutators in $\mathfrak{a}$ vanish, making it an Abelian subalgebra:

Such an Abelian subalgebra is a (horizontal) Cartan subalgebra (CSA) if it is maximal, i.e., if it can not be made any larger (higher-dimensional) without leaving $\mathfrak{p}.$

How many different CSAs are there? Given a CSA $\mathfrak{a},$ we can pick a vertical element $y\in\mathfrak{k}$ and apply the corresponding group element $K=\exp(y)$ to all elements of the CSA, using the adjoint action we studied above. This will yield a valid CSA again: First, $K\mathfrak{a} K^\dagger$ remains in $\mathfrak{p}$ due to the reductive property, as we discussed when introducing the Cartan decomposition. Second, the adjoint action will not change the Abelian property because

Finally, we are guaranteed that $K\mathfrak{a} K^\dagger$ remains maximal:

For most $y\in\mathfrak{k},$ applying $K=\exp(y)$ in this way will yield a different CSA, so that we find a whole continuum of them. It turns out that they all can be found by starting with any $\mathfrak{a}$ and applying all of $\mathcal{K}$ to it.

This is what powers the KAK decomposition.

Example

For our example, we established the decomposition $\mathfrak{su}(2)=\mathfrak{u}(1)\oplus \mathfrak{p}$ with the two-dimensional horizontal space $\mathfrak{p} = \text{span}_{\mathbb{R}}\{iX, iY\}.$ Starting with the subspace $\mathfrak{a}=\text{span}_{\mathbb{R}} \{iY\},$ we see that we immediately reach a maximal Abelian subalgebra (a CSA), because $[Y, X]\neq 0.$ Applying a rotation $\exp(i\eta Z)\in\mathcal{K}$ to this CSA gives us a new CSA via

The vertical group element $\exp(i\eta Z)$ simply rotates the CSA within $\mathfrak{p}.$ Let us not forget to define the CSA in code.

# CSA generator: iY
a = p[1]

# Rotate CSA by applying some vertical group element exp(i eta Z)
eta = 0.6
# The factor -2 compensates the convention -1/2 in the RZ gate
a_prime = qml.RZ(-2 * eta, 0) @ a @ qml.RZ(2 * eta, 0)

# Expectation from our theoretical calculation
a_prime_expected = np.cos(2 * eta) * a + np.sin(2 * eta) * p[0]
a_primes_equal = np.allclose(qml.matrix(a_prime_expected), qml.matrix(a_prime))
print(f"The rotated CSAs match between numerics and theory: {a_primes_equal}")

The rotated CSAs match between numerics and theory: True

Cartan involutions¶

In practice, there often is a more convenient way to obtain a Cartan decomposition than by specifying the subalgebra $\mathfrak{k}$ or its horizontal counterpart $\mathfrak{p}$ manually. It goes as follows.

We will look at a map $\theta$ from the total Lie algebra $\mathfrak{g}$ to itself. We demand that $\theta$ has the following properties, for $x, y\in\mathfrak{g}$ and $c\in\mathbb{R}.$

1. It is linear, i.e., $\theta(x + cy)=\theta(x) +c \theta(y),$

2. It is compatible with the commutator, i.e., $\theta([x, y])=[\theta(x),\theta(y)],$ and

3. It is an involution, i.e., $\theta(\theta(x)) = x,$ or $\theta^2=\mathbb{I}_{\mathfrak{g}}.$

In short, we demand that $\theta$ be an involutive automorphism of $\mathfrak{g}.$

As an involution, $\theta$ only can have the eigenvalues $\pm 1,$ with associated eigenspaces $\mathfrak{g}_\pm.$ Let’s see what happens when we compute commutators between elements $x_\pm\in\mathfrak{g}_\pm \Leftrightarrow \theta(x_\pm) = \pm x_\pm:$

Or, in other words, $[\mathfrak{g}_+, \mathfrak{g}_+] \subset \mathfrak{g}_+,$ $[\mathfrak{g}_+, \mathfrak{g}_-] \subset \mathfrak{g}_-,$ and $[\mathfrak{g}_-, \mathfrak{g}_-] \subset \mathfrak{g}_+.$ So an involution is enough to find us a Cartan decomposition, with $\mathfrak{k}=\mathfrak{g}_+$ and $\mathfrak{p}=\mathfrak{g}_-.$

🤯

We might want to call such a $\theta$ a Cartan involution.

Conversely, if we have a Cartan decomposition based on a subalgebra $\mathfrak{k},$ we can define the map

where $\Pi_{\mathfrak{k},\mathfrak{p}}$ are the projectors onto the two vector subspaces. Clearly, $\theta_{\mathfrak{k}}$ is linear because projectors are. It is also compatible with the commutator due to the commutation relations between $\mathfrak{k}$ and $\mathfrak{p}$ (see box below). Finally, $\theta_{\mathfrak{k}}$ is an involution because

where we used the projectors’ property $\Pi_{\mathfrak{k}}^2=\Pi_{\mathfrak{k}}$ and $\Pi_{\mathfrak{p}}^2=\Pi_{\mathfrak{p}},$ as well as the fact that $\Pi_{\mathfrak{k}}\Pi_{\mathfrak{p}}=\Pi_{\mathfrak{p}}\Pi_{\mathfrak{k}}=0$ because the spaces $\mathfrak{k}$ and $\mathfrak{p}$ are orthogonal to each other.

This shows us that we can easily switch between a Cartan involution and a Cartan decomposition, in either direction!

Example

In our example, an involution that reproduces our choice $\mathfrak{k}=\text{span}_{\mathbb{R}} \{iZ\}$ is $\theta_Z(x) = Z x Z$ (convince yourself that it is an involution that respects commutators, or verify that it matches $\theta_{\mathfrak{k}}$ from above).

def theta_Z(x):
    return qml.simplify(Z(0) @ x @ Z(0))


theta_of_u1 = [theta_Z(x) for x in u1]
u1_is_su2_plus = all(qml.equal(x, theta_of_x) for x, theta_of_x in zip(u1, theta_of_u1))
print(f"U(1) is the +1 eigenspace: {u1_is_su2_plus}")

theta_of_p = [theta_Z(x) for x in p]
p_is_su2_minus = all(qml.equal(-x, theta_of_x) for x, theta_of_x in zip(p, theta_of_p))
print(f"p is the -1 eigenspace: {p_is_su2_minus}")

U(1) is the +1 eigenspace: True
p is the -1 eigenspace: True

We can easily get a new subalgebra by modifying the involution, say, to $\theta_Y(x) = Y x Y,$ expecting that $\mathfrak{k}_Y=\text{span}_{\mathbb{R}} \{iY\}$ becomes the new subalgebra.

def theta_Y(x):
    return qml.simplify(Y(0) @ x @ Y(0))


eigvals = []
for x in su2:
    if qml.equal(theta_Y(x), x):
        eigvals.append(1)
    elif qml.equal(theta_Y(x), -x):
        eigvals.append(-1)
    else:
        raise ValueError("Operator not purely in either eigenspace.")

print(f"Under theta_Y, the operators\n{su2}\nhave the eigenvalues\n{eigvals}")

Under theta_Y, the operators
[X(0), Y(0), Z(0)]
have the eigenvalues
[-1, 1, -1]

This worked! A new involution gave us a new subalgebra and Cartan decomposition.