qml.labs.dla.cartan_subalgebra

cartan_subalgebra(g, k, m, ad, start_idx=0, tol=1e-10, verbose=0, return_adjvec=False, is_orthogonal=True)

Compute a Cartan subalgebra (CSA) $\mathfrak{a} \subseteq \mathfrak{m}$.

A non-unique CSA is a maximal Abelian subalgebra in the horizontal subspace $\mathfrak{m}$ of a Cartan decomposition. Note that this is sometimes called a horizontal CSA, and is different from the definition of a CSA on Wikipedia.

See also

cartan_decomp(), structure_constants(), The KAK decomposition theory(demo), The KAK decomposition in practice (demo).

Parameters

• g (List[Union[PauliSentence, np.ndarray]]) – Lie algebra $\mathfrak{g}$, which is assumed to be ordered as $\mathfrak{g} = \mathfrak{k} \oplus \mathfrak{m}$

• k (List[Union[PauliSentence, np.ndarray]]) – Vertical space $\mathfrak{k}$ from Cartan decomposition $\mathfrak{g} = \mathfrak{k} \oplus \mathfrak{m}$

• m (List[Union[PauliSentence, np.ndarray]]) – Horizontal space $\mathfrak{m}$ from Cartan decomposition $\mathfrak{g} = \mathfrak{k} \oplus \mathfrak{m}$

• ad (Array) – The $|\mathfrak{g}| \times |\mathfrak{g}| \times |\mathfrak{g}|$ dimensional adjoint representation of $\mathfrak{g}$ (see structure_constants())

• start_idx (bool) – Indicates from which element in m the CSA computation starts.

• tol (float) – Numerical tolerance for linear independence check

• verbose (bool) – Whether or not to output progress during computation

• return_adjvec (bool) – The output format. If False, returns operators in their original input format (matrices or PauliSentence). If True, returns the spaces as adjoint representation vectors.

• is_orthogonal (bool) – Whether the basis elements are all orthogonal, both within and between g, k and m.

Returns

A tuple of adjoint vector representations (newg, k, mtilde, a, new_adj), corresponding to $\mathfrak{g}$, $\mathfrak{k}$, $\tilde{\mathfrak{m}}$, $\mathfrak{a}$ and the new adjoint representation. The dimensions are (|g|, |g|), (|k|, |g|), (|mtilde|, |g|), (|a|, |g|) and (|g|, |g|, |g|), respectively.

Return type

Tuple(np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray)

Example

A quick example computing a Cartan subalgebra of $\mathfrak{su}(4)$ using the Cartan involution even_odd_involution().

>>> import pennylane as qml
>>> from pennylane.labs.dla import cartan_decomp, cartan_subalgebra, even_odd_involution
>>> g = list(qml.pauli.pauli_group(2)) # u(4)
>>> g = g[1:] # remove identity -> su(4)
>>> g = [op.pauli_rep for op in g] # optional; turn to PauliSentence for convenience
>>> k, m = cartan_decomp(g, even_odd_involution)
>>> g = k + m # re-order g to separate k and m
>>> adj = qml.structure_constants(g)
>>> newg, k, mtilde, a, new_adj = cartan_subalgebra(g, k, m, adj)
>>> newg == k + mtilde + a
True
>>> a
[-1.0 * Z(0) @ Z(1), 1.0 * Y(0) @ Y(1), -1.0 * X(0) @ X(1)]

We can confirm that these all commute with each other, as the CSA is Abelian (= all operators commute).

>>> from pennylane.labs.dla import check_all_commuting
>>> check_all_commuting(a)
True

We can opt-in to return what we call adjoint vectors of dimension $|\mathfrak{g}|$, where each component corresponds to an entry in (the ordered) g. The adjoint vectors for the Cartan subalgebra are in np_a.

>>> np_newg, np_k, np_mtilde, np_a, new_adj = cartan_subalgebra(g, k, m, adj, return_adjvec=True)

We can reconstruct an operator by computing $\hat{O}_v = \sum_i v_i g_i$ for an adjoint vector $v$ and $g_i \in \mathfrak{g}$.

>>> v = np_a[0]
>>> op = sum(v_i * g_i for v_i, g_i in zip(v, g))
>>> op.simplify()
>>> op
-1.0 * Z(0) @ Z(1)

For convenience, we provide a helper function adjvec_to_op() for the collections of adjoint vectors in the returns.

>>> from pennylane.labs.dla import adjvec_to_op
>>> a = adjvec_to_op(np_a, g)
>>> a
[-1.0 * Z(0) @ Z(1), 1.0 * Y(0) @ Y(1), -1.0 * X(0) @ X(1)]

Usage Details

Let us walk through an example of computing the Cartan subalgebra. The basis for computing the Cartan subalgebra is having the Lie algebra $\mathfrak{g}$, a Cartan decomposition $\mathfrak{g} = \mathfrak{k} \oplus \mathfrak{m}$ and its adjoint representation.

We start by computing these ingredients using cartan_decomp() and structure_constants(). As an example, we take the Lie algebra of the Heisenberg model with generators $\{X_i X_{i+1}, Y_i Y_{i+1}, Z_i Z_{i+1}\}$.

>>> from pennylane.labs.dla import lie_closure_dense, cartan_decomp
>>> from pennylane import X, Y, Z
>>> n = 3
>>> gens = [X(i) @ X(i+1) for i in range(n-1)]
>>> gens += [Y(i) @ Y(i+1) for i in range(n-1)]
>>> gens += [Z(i) @ Z(i+1) for i in range(n-1)]
>>> g = lie_closure_dense(gens)

Taking the Heisenberg Lie algebra, we can perform the Cartan decomposition. We take the even_odd_involution() as a valid Cartan involution. The resulting vertical and horizontal subspaces $\mathfrak{k}$ and $\mathfrak{m}$ need to fulfill the commutation relations $[\mathfrak{k}, \mathfrak{k}] \subseteq \mathfrak{k}$, $[\mathfrak{k}, \mathfrak{m}] \subseteq \mathfrak{m}$ and $[\mathfrak{m}, \mathfrak{m}] \subseteq \mathfrak{k}$, which we can check using the helper function check_cartan_decomp().

>>> from pennylane.labs.dla import even_odd_involution, check_cartan_decomp
>>> k, m = cartan_decomp(g, even_odd_involution)
>>> check_cartan_decomp(k, m) # check commutation relations of Cartan decomposition
True

Our life is easier when we use a canonical ordering of the operators. This is why we re-define g with the new ordering in terms of operators in k first, and then all remaining operators from m.

>>> import numpy as np
>>> from pennylane.labs.dla import structure_constants_dense
>>> g = np.vstack([k, m]) # re-order g to separate k and m operators
>>> adj = structure_constants_dense(g) # compute adjoint representation of g

Finally, we can compute a Cartan subalgebra $\mathfrak{a}$, a maximal Abelian subalgebra of $\mathfrak{m}$.

>>> newg, k, mtilde, a, new_adj = cartan_subalgebra(g, k, m, adj, start_idx=3)

The new DLA newg is just the concatenation of k, mtilde, a. Each component is returned in the original input format. Here we obtain collections of $8\times 8$ matrices (numpy arrays), as this is what we started from.

>>> newg.shape, k.shape, mtilde.shape, a.shape, new_adj.shape
((15, 8, 8), (6, 8, 8), (6, 8, 8), (3, 8, 8), (15, 15, 15))

We can also let the function return what we call adjoint representation vectors.

>>> kwargs = {"start_idx": 3, "return_adjvec": True}
>>> np_newg, np_k, np_mtilde, np_a, new_adj = cartan_subalgebra(g, k, m, adj, **kwargs)
>>> np_newg.shape, np_k.shape, np_mtilde.shape, np_a.shape, new_adj.shape
((15, 15), (6, 15), (6, 15), (3, 15), (15, 15, 15))

These are dense vector representations of dimension $|\mathfrak{g}|$, in which each entry corresponds to the respective operator in $\mathfrak{g}$. Given an adjoint representation vector $v$, we can reconstruct the respective operator by simply computing $\hat{O}_v = \sum_i v_i g_i$, where $g_i \in \mathfrak{g}$ (hence the need for a canonical ordering).

We provide a convenience function adjvec_to_op() that works with both g represented as dense matrices or PL operators. Because we used dense matrices in this example, we transform the operators back to PennyLane operators using pauli_decompose().

>>> from pennylane.labs.dla import adjvec_to_op
>>> a = adjvec_to_op(np_a, g)
>>> h_op = [qml.pauli_decompose(op).pauli_rep for op in a]
>>> h_op
[-1.0 * Y(1) @ Y(2), -1.0 * Z(1) @ Z(2), 1.0 * X(1) @ X(2)]

In that case we chose a Cartan subalgebra from which we can readily see that it is commuting, but we also provide a small helper function to check that.

>>> from pennylane.labs.dla import check_all_commuting
>>> assert check_all_commuting(h_op)

Last but not least, the adjoint representation new_adj is updated to represent the new basis and its ordering of g.

code/api/api/pennylane.labs.dla.cartan_subalgebra

 

Download Python script

 

Download Notebook

 

View on GitHub