🚀 Get Started with LieGroups.jl

Introduction

This tutorial introduces both a few basics of Lie groups as well as how to use LieGroups.jl. The Lie groups we consider are the rotations in the plane, or special orthogonal group as well as rigid body motions, or in other words the special euclidean group.

In a nutshell a Lie group $𝒢$ is a manifold $ℳ$ that also is a group with a group operation.

A manifold can informally be described as a set that “locally looks like a Euclidean space” and has some way to measure angles at every point. Formally, this yields an inner product that depends (smoothly) on the point one is at. For Lie groups this will be a bit easier.

A group means that on the set there also exists an operation, within this package usually denoted by $∘: 𝒢 × 𝒢 → 𝒢$, LieGroups.jl uses the manifolds defined in Manifolds.jl. For more details on that, see also the introductory tutorial there. A Lie group is usually written as a tuple $(ℳ,∘)$ with the manifold and the group operation thereon.

For more theoretical background, see for example [HN12], especially their Chapter 9.

Rotations on the plane $ℝ^2$ and in $ℝ^3$.

This first part considers rotations in the plane. These can be represented by rotation matrices

\[R_α = \begin{pmatrix} \cos(α)& -\sin(α)\\ \sin(α) & \cos(α) \end{pmatrix},\qquad α ∈ ℝ,\]

where we already represent all possible rotations when restricting $α$ to $[0,2π]$. Adding two matrices $R_α + R_β$ does not yield a valid rotation matrix again, but we can have these matrices in mind as being “locally like the real line”, since changing the rotation angle slightly yields rotation matrices that are “close by” in the sense that they perform nearly the same rotation when applied to a point $x ∈ ℝ^2$ by computing $R_αx$. Matrix multiplication $R_β = R_{α_1} R_{α_2}$ does yield a new rotation and also fulfills all other properties to yield a group operation. Using trigonometric identities we observe that $R_β = R_{α_1+α_2}$. Since the angle of rotation is $2π$-periodic, we also see here, that e.g. for small angles around $0$, this behaves like the real line, but globally it differs, since $R_{α} = R_{α+2π}$

The set of rotation matrices is hence a Lie group and called the special orthogonal group $\mathrm{SO}(2)$. In LieGroups.jl we initialise this as

using LieGroups, LinearAlgebra, RecursiveArrayTools, Rotations
SO2 = SpecialOrthogonalGroup(2)

SpecialOrthogonalGroup(2)

Elements $g, h ∈ \mathrm{SO}(2)$ we generate as

g = [1.0 0.0; 0.0 1.0]
h = 1/sqrt(2) .* [1.0 -1.0; 1.0 1.0]

2×2 Matrix{Float64}:
 0.707107  -0.707107
 0.707107   0.707107

A first thing to do is to use is_point to verify they are valid.

(is_point(SO2, g), is_point(SO2, h))

(true, true)

The already mentioned group operation as the matrix multiplication, there is also a generic function available, compose as well as its in-place variant compose!. The following two yield the same matrix

[ compose(SO2, g, h), g*h ]

2-element Vector{Matrix{Float64}}:
 [0.7071067811865475 -0.7071067811865475; 0.7071067811865475 0.7071067811865475]
 [0.7071067811865475 -0.7071067811865475; 0.7071067811865475 0.7071067811865475]

Furthermore a lot of of functions are “passed down” tp the manifold, which is stored within the LieGroup. For example the dimension of the manifold, or the number of degrees of freedom can be accessed via the manifold_dimension

manifold_dimension(SO2)

1

The Lie algebra, and the Lie group exponential function.

For the following investigations, we consider the special orthogonal group $\mathrm{SO}(3)$, that is rotations in a 3-dimensional space. Besides one special rotation in the following code for completeness, a prominent, at first glace maybe a bit “dull” point on this Lie group is the identity matrix e.

SO3 = SpecialOrthogonalGroup(3)
g = RotZ(π/3)*RotY(π/4)
e = Matrix{Float64}(I,3,3)
g

3×3 RotZY{Float64} with indices SOneTo(3)×SOneTo(3)(1.0472, 0.785398):
  0.353553  -0.866025  0.353553
  0.612372   0.5       0.612372
 -0.707107   0.0       0.707107

The element g can be seen as a rotation by $π/3$ in the x-y-plane combined with a rotation by $π/4$ in the x-z plane.

The tangent space $T_e𝒢$ plays a special role and is called the LieAlgebra $𝔤$.

Similar to the Riemannian exponential map The exponential function $\exp_𝒢: 𝔤 → 𝒢$ maps Lie algebra tangent vectors $X ∈ T_e𝒢$ to a point on the Lie group. This is implemented in exp(G::LieGroup, X). Its inverse is the Lie group logarithmic function log(G::LieGroup, g).

X = log(SO3,g)
is_point(LieAlgebra(SO3), X)

true

exp(SO3,X)

3×3 StaticArraysCore.MMatrix{3, 3, Float64, 9} with indices SOneTo(3)×SOneTo(3):
  0.353553  -0.866025     0.353553
  0.612372   0.5          0.612372
 -0.707107  -5.55112e-17  0.707107

The term “exponential” has at least three different meanings throughout Lie groups and Riemannian manifolds. To be precise, we call the just introduced one “exponential function”, since it often agrees with the matrix exponential.

Taking a closed look at X we see

X

3×3 StaticArraysCore.MMatrix{3, 3, Float64, 9} with indices SOneTo(3)×SOneTo(3):
  0.0       -0.990825  0.710856
  0.990825   0.0       0.410413
 -0.710856  -0.410413  0.0

an example that all elements from the Lie algebra are skew symmetric matrices. This allows for one way to see that we have three degrees of freedom, cf

manifold_dimension(SO3)

3

As the Lie algebra was introduced via a tangent space, we also know that it is a vector space. To “turn” the X into a vector with three elements, we need a basis of the tangent space to decompose X into and “read off” its components. While in general this can be done using the bases of a tangent space from ManifoldsBase.jl, a very specific one is vee(::LieAlgebra, X)

c = vee(LieAlgebra(SO3), X)

3-element Vector{Float64}:
 -0.41041311978624273
  0.7108563755626242
  0.990824919963801

and its inverse, hat(G::LieAlgebra, c)

X_ = hat(LieAlgebra(SO3),c)

3×3 Matrix{Float64}:
  0.0       -0.990825  0.710856
  0.990825   0.0       0.410413
 -0.710856  -0.410413  0.0

Representing tangent vectors

Consider the function of left group composition $λ_g(h) = g∘h$. Its differential (or push forward) $Dλ_g(e)$ maps from $T_e𝒢$ to $T_g𝒢$ and is a linear bijection between both spaces. Its adjoint differential (or pullback) $D^*λ_g(e)$ maps back from $T_g𝒢$ to $T_e𝒢$.

This allows to introduce an inner product on all tangent spaces, that smoothly varies with the base point, we obtain the left-invariant metric

\[⟨X,Y⟩_g = ⟨D^*λ_g(e)[X],D^*λ_g(e)⟩_e,\]

since it is invariant if you use the differential of the left composition to identify tangent vectors. We can even “spare” the pullbacks in this definition, when representing tangent vector alsways by their correspnding representants in the Lie algebra. This is the default in LieGroups.jl.

Alternatively one can start with the right composition and its differential to arrive an right-invariant vector fields and a right-invariant metric.

The left-invariant metric is in general not right-invariant, except for compact Lie groups and their direct products with translations, see for example [LT13] for an even more general proof.

With respect to this metric on the manifold the exponential and logarithmic maps are given by

\[\exp_g(X) = g ∘ \exp_𝒢(X) \quad\text{with its inverse}\quad \log_g(h) = \log_𝒢(g^{-1}∘h)\]

With respect to these geodesics and the representation in the Lie algebra, parallel transport simplifies to the identity. To still access the Riemannian exponential map with respect to the metric (compatible to the Levi-Civita connection) on the underlying Riemannian manifold, use exp(base_manifold(G), g, X).

As an example, we compute

h = exp(SO3, g, X)

3×3 StaticArraysCore.MMatrix{3, 3, Float64, 9} with indices SOneTo(3)×SOneTo(3):
 -0.65533    -0.739199  -0.15533
  0.0896799  -0.28033    0.955705
 -0.75        0.612372   0.25

and its inverse is returning X as well.

log(SO3, g, h)

3×3 StaticArraysCore.MMatrix{3, 3, Float64, 9} with indices SOneTo(3)×SOneTo(3):
  0.0       -0.990825  0.710856
  0.990825   0.0       0.410413
 -0.710856  -0.410413  0.0

The Special Euclidean group $\mathrm{SE}(3)$ of rigid body motions

There are two further ingredients this tutorial needs to get towards rigid body motions.

Group actions

For a group like $\mathrm{SO}(3)$ an action describes how points $g ∈ 𝒢$ can act on points from a Riemannian manifold $p ∈ ℳ$ – in short an action of a certain AbstractGroupActionType ”combines“ $p$ and $g$ into a new element $q = σ_g(p)$. In the example of $𝒢=\mathrm{SO}(3)$ and $ℳ=ℝ^3$ the action is (just) the application of the rotation or the matrix-vector multiplication $σ_g(p)=gp$. A special case is, when $ℳ$ itself is also a Lie group. In the example this is the case, since together with vector addition $p+q$ we get the TranslationGroup $T(3) = (ℝ^3, +)$ Depending on how the concatenation of two types, the AbstractLeftGroupActionType like the one here and a AbstractRightGroupActionType.

T3 = TranslationGroup(3)

TranslationGroup(3; field=ℝ)

Products and semidirect products of Lie groups

Similar to product manifolds (direct) product Lie groups are formed the same way. For two Lie groups $𝒢 = 𝒢_1 × 𝒢_2$ is the product of the two manifolds together with the component wise application of the group operations: the first group operation (of $𝒢_1$) to the first component and that of $𝒢_2$ to the second.

Instead of the component wise or “not interacting” variant of the (direct) product Lie groups, for the semidirect product Lie groups $𝒢 = 𝒢_1 ⋉ 𝒢_2$ we also require an action of how $𝒢_1$ acts on $𝒢_2$. Semidirect here means that the first component of $𝒢$ is the same as for the direct product, but before applying the second group operation on $𝒢_2$ one of the elements is “acted upon” from an element of $𝒢_1$. The group operation reads for $(g_1,g_2), (h_1,h_2) ∈ 𝒢$

\[(g_1,g_2) ∘ (h_1,h_2) := (g_1 ⋆ h_1, σ_{h_1}(g_2) ⋄ h_2).\]

Rigid body motions

We obtain the special Euclidean group $\mathrm{SE}(3) = \mathrm{SO}(3) ⋉ T(3)$ where the group action is the one discussed as an example before.

SE3 = SpecialEuclideanGroup(3)

SpecialEuclideanGroup(3)

which we could also generate with SO3 and T3 from before as

SO3 ⋉ T3

SpecialEuclideanGroup(3)

This call employs the default_left_action(SO3,T3) to determine the action for the semidirect product Lie group. This is defined whenever for two Lie groups, their (left) action is clear, because there exists a reasonable default. Otherwise the full form

LeftSemidirectProductLieGroup(SO3, T3, LeftGroupOperationAction())

SpecialEuclideanGroup(3)

is necessary. Here, the first Left for the semidirect product refers to the fact that the left group acts on the right one before the right group operation is performed. LeftGroupOperationAction refers to that the group operation – left multiplication with a matrix – is applied here.

For this case, any point $\mathrm{SE}(3)$ is a tuple of a rotation matrix and a vector. We model this using RecursiveArrayTools.jl, namely its ArrayPartition. For example with the rotation matrix g from before we have

g1 = ArrayPartition(g, [1.0, 0.0, 2.0])

([0.35355339059327384 -0.8660254037844386 0.3535533905932738; 0.6123724356957946 0.5000000000000001 0.6123724356957945; -0.7071067811865475 0.0 0.7071067811865476], [1.0, 0.0, 2.0])

and for a pure translation we can reuse e as in

h1 = ArrayPartition(e, [0.0, 3.0, 0.0])

([1.0 0.0 0.0; 0.0 1.0 0.0; 0.0 0.0 1.0], [0.0, 3.0, 0.0])

and we can summarize a few operations from before: both are valid points on SE3

(is_point(SE3, g1), is_point(SE3, h1))

(true, true)

we can perform the group operation

gh1 = compose(SE3, g1, h1)

([0.35355339059327384 -0.8660254037844386 0.3535533905932738; 0.6123724356957946 0.5000000000000001 0.6123724356957945; -0.7071067811865475 0.0 0.7071067811865476], [-1.598076211353316, 1.5000000000000004, 2.0])

apply the Lie group exponential

Y = log(SE3, gh1)

([0.0 -0.990824919963801 0.7108563755626242; 0.990824919963801 0.0 0.41041311978624273; -0.7108563755626242 -0.41041311978624273 0.0], [-1.4693272604812524, 1.8941219089183496, 1.7705711589135078])

and look at the manifold dimension, it is the sum of dimensions of its components

manifold_dimension(SE3)

6

The coordinates of Y are

vee(LieAlgebra(SE3), Y)

6-element Vector{Float64}:
 -0.41041311978624273
  0.7108563755626242
  0.990824919963801
 -1.4693272604812524
  1.8941219089183496
  1.7705711589135078

which actually is component wise again, the first 3 values refer to the rotation part, the second three to the translation part.

Technical details

This tutorial is cached. It was last run on the following package versions.

Status `~/work/LieGroups.jl/LieGroups.jl/tutorials/Project.toml`
  [7073ff75] IJulia v1.26.0
  [6774de46] LieGroups v0.0.3 `~/work/LieGroups.jl/LieGroups.jl`
  [1cead3c2] Manifolds v0.10.14
  [731186ca] RecursiveArrayTools v3.31.1
  [6038ab10] Rotations v1.7.1

This tutorial was last rendered March 19, 2025, 18:45:43.

Literature