An interface for Lie groups

LieGroup{𝔽, O<:AbstractGroupOperation, M<:AbstractManifold{𝔽}} <: AbstractManifold{𝔽}

Represent a Lie Group $\mathcal G$.

A Lie Group $\mathcal G$ is a group endowed with the structure of a manifold such that the group operations $∘: \mathcal G×\mathcal G → \mathcal G$, see compose and the inverse operation $⋅^{-1}: \mathcal G → \mathcal G$, see inv are smooth, see for example [HN12, Definition 9.1.1].

Lie groups are named after the Norwegian mathematician Marius Sophus Lie (1842–1899).

Fields

• manifold: an AbstractManifold $\mathcal M$
• op: an AbstractGroupOperation $∘$ on that manifold

Constructor

LieGroup(M::AbstractManifold, op::AbstractGroupOperation)

Generate a Lie group based on a manifold M and a group operation op, where vectors by default are stored in the Lie Algebra.

adjoint(G::LieGroup, g X)
adjoint!(G::LieGroup, Y, g, X)

Compute the adjoint $\mathrm{Ad}(g): \mathfrak g → \mathfrak g$, which is defined as the differential diff_conjugate of the conjugate $c_g(h) = g∘h∘g^{-1}$ evaluated at the Identity $h=\mathrm{e}$. The operation can be performed in-place of Y.

\[ \mathrm{Ad}(g)[X] = D c_g(\mathrm{e}) [X], \qquad X ∈ \mathfrak g.\]

see [HN12, Section 9.2.3].

On matrix Lie groups the adjoint reads $\mathrm{Ad}(g)[X] = g∘X∘g^{-1}$.

exp(G::LieGroup, g, X, t::Number=1)
exp!(G::LieGroup, h, g, X, t::Number=1)

Compute the Lie group exponential map given by

\[\exp_g X = g∘\exp_{\mathcal G}(X)\]

where X can be scaled by t, the computation can be performed in-place of h, and $\exp_{\mathcal G}$ denotes the Lie group exponential function.

exp(G::LieGroup, e::Identity, X)
exp!(G::LieGroup, h, e::Identity, X)

Compute the (Lie group) exponential function

\[\exp_{\mathcal G}: \mathfrak g → \mathcal G,\qquad \exp_{\mathcal G}(X) = γ_X(1),\]

where $γ_X$ is the unique solution of the initial value problem

\[γ(0) = \mathrm{e}, \quad γ'(t) = γ(t)⋅X.\]

The computation can be performed in-place of h.

See also [HN12, Definition 9.2.2].

inv(G::LieGroup, g)
inv!(G::LieGroup, h, g)

Compute the inverse group element $g^{-1}$ with respect to the AbstractGroupOperation $∘$ on the LieGroup $\mathcal G$, that is, return the unique element $h=g^{-1}$ such that $h∘g=\mathrm{e}$, where $\mathrm{e}$ denotes the Identity.

This can be done in-place of h, without side effects, that is you can do inv!(G, g, g).

isapprox(M::LieGroup, g, h; kwargs...)

Check if points g and h from LieGroup are approximately equal. this function calls the corresponding isapprox on the AbstractManifold after handling the cases where one or more of the points are the Identity. All keyword argments are passed to this function as well.

log(G::LieGroup, g, h)
log!(G::LieGroup, X, g, h)

Compute the Lie group logarithmic map

\[\log_g h = \log_{\mathcal G}(g^{-1}∘h)\]

where $\log_{\mathcal G}$ denotes the Lie group logarithmic function The computation can be performed in-place of X.

log(G::LieGroup, e::Identity, g)
log!(G::LieGroup, X, e::Identity, g)

Compute the (Lie group) logarithmic function $\log_{\mathcal G}: \mathcal G → \mathfrak g$, which is the inverse of the Lie group exponential function The compuation can be performed in-place of X.

rand(::LieGroup; vector_at=nothing, σ::Real=1.0, kwargs...)
rand(::LieAlgebra; σ::Real=1.0, kwargs...)
rand!(::LieGroup, gX; vector_at=nothing, σ::Real=1.0, kwargs...)
rand!(::LieAlgebra, X; σ::Real=1.0, kwargs...)

Compute a random point or tangent vector on a Lie group.

For points this just means to generate a random point on the underlying manifold itself.

For tangent vectors, an element in the Lie Algebra is generated, see also rand(::LieAlgebra; kwargs...)

adjoint(G::LieGroup, g X)
adjoint!(G::LieGroup, Y, g, X)

Compute the adjoint $\mathrm{Ad}(g): \mathfrak g → \mathfrak g$, which is defined as the differential diff_conjugate of the conjugate $c_g(h) = g∘h∘g^{-1}$ evaluated at the Identity $h=\mathrm{e}$. The operation can be performed in-place of Y.

\[ \mathrm{Ad}(g)[X] = D c_g(\mathrm{e}) [X], \qquad X ∈ \mathfrak g.\]

see [HN12, Section 9.2.3].

On matrix Lie groups the adjoint reads $\mathrm{Ad}(g)[X] = g∘X∘g^{-1}$.

compose(G::LieGroup, g, h)
compose!(G::LieGroup, k, g, h)

Perform the group oepration $g ∘ h$ for two $g, h ∈ \mathcal G$ on the LieGroup G. This can also be done in-place of h.

conjugate(G::LieGroup, g, h)
conjugate!(G::LieGroup, k, g, h)

Compute the conjugation map $c_g: \mathcal G → \mathcal G$ given by $c_g(h) = g∘h∘g^{-1}$. This can be done in-place of k.

conjugate(G::LieGroup, g, h)
conjugate!(G::LieGroup, k, g, h)

Compute the conjugation map $c_g: \mathcal G → \mathcal G$ given by $c_g(h) = g∘h∘g^{-1}$. This can be done in-place of k.

diff_conjugate(G::LieGroup, g, h, X)
diff_conjugate!(G::LieGroup, Y, g, h, X)

Compute the differential of the conjugate $c_g(h) = g∘h∘g^{-1}$, which can be performed in-place of Y.

\[ D(c_g(h))[X], \qquad X ∈ \mathfrak g.\]

diff_conjugate(G::LieGroup, g, h, X)
diff_conjugate!(G::LieGroup, Y, g, h, X)

Compute the differential of the conjugate $c_g(h) = g∘h∘g^{-1}$, which can be performed in-place of Y.

\[ D(c_g(h))[X], \qquad X ∈ \mathfrak g.\]

diff_inv(G::LieGroup, g, X)
diff_inv!(G::LieGroup, Y, g, X)

Compute the differential of the function $ι_{\mathcal G}(g) = g^{-1}$, where $Dι_{\mathcal G}(g): \mathfrak g → \mathfrak g$. This can be done in-place of Y.

diff_inv(G::LieGroup, g, X)
diff_inv!(G::LieGroup, Y, g, X)

Compute the differential of the function $ι_{\mathcal G}(g) = g^{-1}$, where $Dι_{\mathcal G}(g): \mathfrak g → \mathfrak g$. This can be done in-place of Y.

diff_left_compose(G::LieGroup, g, h, X)
diff_left_compose!(G::LieGroup, Y, g, h, X)

Compute the differential of the left group multiplication $λ_g(h) = g∘h$, on the LieGroup G, that is Compute $Dλ_g(h)[X]$, $X ∈ 𝔤$. This can be done in-place of Y.

diff_left_compose(G::LieGroup, g, h, X)
diff_left_compose!(G::LieGroup, Y, g, h, X)

Compute the differential of the left group multiplication $λ_g(h) = g∘h$, on the LieGroup G, that is Compute $Dλ_g(h)[X]$, $X ∈ 𝔤$. This can be done in-place of Y.

diff_right_compose(G::LieGroup, h, g, X)
diff_right_compose!(G::LieGroup, Y, h, g, X)

Compute the differential of the right group multiplication $ρ_g(h) = h∘g$, on the LieGroup G, that is Compute $Dρ_g(h)[X]$, $X ∈ 𝔤$ This can be done in-place of Y.

diff_right_compose(G::LieGroup, h, g, X)
diff_right_compose!(G::LieGroup, Y, h, g, X)

Compute the differential of the right group multiplication $ρ_g(h) = h∘g$, on the LieGroup G, that is Compute $Dρ_g(h)[X]$, $X ∈ 𝔤$ This can be done in-place of Y.

identity_element(G::LieGroup)
identity_element!(G::LieGroup, e)

Return a point representation of the Identity on the LieGroup G. By default this representation is the default array or number representation. It should return the corresponding default representation of $e$ as a point on G if points are not represented by arrays. This can be performed in-place of e.

inv(G::LieGroup, g)
inv!(G::LieGroup, h, g)

Compute the inverse group element $g^{-1}$ with respect to the AbstractGroupOperation $∘$ on the LieGroup $\mathcal G$, that is, return the unique element $h=g^{-1}$ such that $h∘g=\mathrm{e}$, where $\mathrm{e}$ denotes the Identity.

This can be done in-place of h, without side effects, that is you can do inv!(G, g, g).

compose(G::LieGroup, g, h)
compose!(G::LieGroup, k, g, h)

Perform the group oepration $g ∘ h$ for two $g, h ∈ \mathcal G$ on the LieGroup G. This can also be done in-place of h.

inv_left_compose(G::LieGroup, g, h)
inv_left_compose!(G::LieGroup, k, g, h)

Compute the inverse of the left group operation $λ_g(h) = g∘h$, on the LieGroup G, that is, compute $λ_g^{-1}(h) = g^{-1}∘h$. This can be done in-place of k.

inv_right_compose(G::LieGroup, h, g)
inv_right_compose!(G::LieGroup, k, h, g)

Compute the inverse of the right group operation $ρ_g(h) = h∘g$, on the LieGroup G, that is compute $ρ_g^{-1}(h) = h∘g^{-1}$. This can be done in-place of k.

inv_right_compose(G::LieGroup, h, g)
inv_right_compose!(G::LieGroup, k, h, g)

Compute the inverse of the right group operation $ρ_g(h) = h∘g$, on the LieGroup G, that is compute $ρ_g^{-1}(h) = h∘g^{-1}$. This can be done in-place of k.

compose(G::LieGroup, g, h)
compose!(G::LieGroup, k, g, h)

Perform the group oepration $g ∘ h$ for two $g, h ∈ \mathcal G$ on the LieGroup G. This can also be done in-place of h.

identity_element(G::LieGroup)
identity_element!(G::LieGroup, e)

Return a point representation of the Identity on the LieGroup G. By default this representation is the default array or number representation. It should return the corresponding default representation of $e$ as a point on G if points are not represented by arrays. This can be performed in-place of e.

is_identity(G::LieGroup, q; kwargs)

Check whether q is the identity on the LieGroup $\mathcal G$. This means it is either the Identity{O} with the respect to the corresponding AbstractGroupOperation O, or (approximately) the correct point representation.

See also

identity_element, identity_element!

base_manifold(G::LieGroup)

Return the manifold stored within the LieGroup G.

exp(G::LieGroup, g, X, t::Number=1)
exp!(G::LieGroup, h, g, X, t::Number=1)

Compute the Lie group exponential map given by

\[\exp_g X = g∘\exp_{\mathcal G}(X)\]

where X can be scaled by t, the computation can be performed in-place of h, and $\exp_{\mathcal G}$ denotes the Lie group exponential function.

exp(G::LieGroup, e::Identity, X)
exp!(G::LieGroup, h, e::Identity, X)

Compute the (Lie group) exponential function

\[\exp_{\mathcal G}: \mathfrak g → \mathcal G,\qquad \exp_{\mathcal G}(X) = γ_X(1),\]

where $γ_X$ is the unique solution of the initial value problem

\[γ(0) = \mathrm{e}, \quad γ'(t) = γ(t)⋅X.\]

The computation can be performed in-place of h.

See also [HN12, Definition 9.2.2].

exp(G::LieGroup, e::Identity, X)
exp!(G::LieGroup, h, e::Identity, X)

Compute the (Lie group) exponential function

\[\exp_{\mathcal G}: \mathfrak g → \mathcal G,\qquad \exp_{\mathcal G}(X) = γ_X(1),\]

where $γ_X$ is the unique solution of the initial value problem

\[γ(0) = \mathrm{e}, \quad γ'(t) = γ(t)⋅X.\]

The computation can be performed in-place of h.

See also [HN12, Definition 9.2.2].

get_coordinates(G::LieGroup, g, X, B::AbstractBasis)
get_coordinates(𝔤::LieAlgebra, X, B::AbstractBasis)
get_coordinates!(G::LieGroup, c, g, X, B::AbstractBasis)
get_coordinates!(𝔤::LieAlgebra, c, X, B::AbstractBasis)

Return the vector of coordinates to the decomposition of X with respect to an AbstractBasis of the LieAlgebra 𝔤. Since all tangent vectors are assumed to be represented in the Lie algebra, both signatures are equivalent. The operation can be performed in-place of c.

By default this function requires identity_element(G) and calls the corresponding get_coordinates function of the Riemannian manifold the Lie group is build on.

The inverse operation is get_vector.

See also vee.

exp(G::LieGroup, e::Identity, X)
exp!(G::LieGroup, h, e::Identity, X)

Compute the (Lie group) exponential function

\[\exp_{\mathcal G}: \mathfrak g → \mathcal G,\qquad \exp_{\mathcal G}(X) = γ_X(1),\]

where $γ_X$ is the unique solution of the initial value problem

\[γ(0) = \mathrm{e}, \quad γ'(t) = γ(t)⋅X.\]

The computation can be performed in-place of h.

See also [HN12, Definition 9.2.2].

get_vector(G::LieGroup, g, c, B::AbstractBasis)
get_vector(𝔤::LieAlgebra, c, B::AbstractBasis)
get_vector!(G::LieGroup, X, g, c, B::AbstractBasis)
get_vector!(𝔤::LieAlgebra, X, c, B::AbstractBasis)

Return the vector corresponding to a set of coefficients in an AbstractBasis of the LieAlgebra 𝔤. Since all tangent vectors are assumed to be represented in the Lie algebra, both signatures are equivalend. The operation can be performed in-place of a tangent vector X.

By default this function requires identity_element(G) and calls the corresponding get_vector function of the Riemannian manifold the Lie group is build on.

The inverse operation is get_coordinates.

See also hat

hat(G::LieGroup, c)
hat!(G::LieGroup, X, c)

Compute the hat map $(⋅)^̂$ that maps a vector of coordinates $c_i$ with respect to a certain basis to a tangent vector in the Lie algebra

\[X = \sum_{i∈\mathcal I} c_iB_i,\]

where $\{ B_i \}_{i∈\mathcal I}$ is a basis of the Lie algebra and $\mathcal I$ a corresponding index set, which is usually $\mathcal I=\{ 1,\ldots,n \}$.

The computation can be performed in-place of X. The inverse of hat is vee.

Technically, hat is a specific case of get_vector and is implemented using the LieAlgebraOrthogonalBasis

hat(G::LieGroup, c)
hat!(G::LieGroup, X, c)

Compute the hat map $(⋅)^̂$ that maps a vector of coordinates $c_i$ with respect to a certain basis to a tangent vector in the Lie algebra

\[X = \sum_{i∈\mathcal I} c_iB_i,\]

where $\{ B_i \}_{i∈\mathcal I}$ is a basis of the Lie algebra and $\mathcal I$ a corresponding index set, which is usually $\mathcal I=\{ 1,\ldots,n \}$.

The computation can be performed in-place of X. The inverse of hat is vee.

Technically, hat is a specific case of get_vector and is implemented using the LieAlgebraOrthogonalBasis

is_point(G::LieGroup, g; kwargs...)

Check whether g is a valid point on the Lie Group G. This falls back to checking whether g is a valid point on G.manifold, unless g is an Identity. Then, it is checked whether it is the identity element corresponding to G.

is_vector(G::LieGroup, X; kwargs...)
is_vector(G::LieGroup{𝔽,O}, e::Indentity{O}, X; kwargs...)

Check whether X is a tangent vector, that is an element of the LieAlgebra of G. The first variant calls is_point on the LieAlgebra 𝔤 of G. The second variant calls is_vector on the AbstractManifold at the identity_element.

All keyword arguments are passed on to the corresponding call

is_vector(G::LieGroup, X; kwargs...)
is_vector(G::LieGroup{𝔽,O}, e::Indentity{O}, X; kwargs...)

Check whether X is a tangent vector, that is an element of the LieAlgebra of G. The first variant calls is_point on the LieAlgebra 𝔤 of G. The second variant calls is_vector on the AbstractManifold at the identity_element.

All keyword arguments are passed on to the corresponding call

log(G::LieGroup, g, h)
log!(G::LieGroup, X, g, h)

Compute the Lie group logarithmic map

\[\log_g h = \log_{\mathcal G}(g^{-1}∘h)\]

where $\log_{\mathcal G}$ denotes the Lie group logarithmic function The computation can be performed in-place of X.

vee(G::LieGroup, X)
vee!(G::LieGroup, c, X)

Compute the vee map $(⋅)^∨$ that maps a tangent vector X from the LieAlgebra to its coordinates with respect to the LieAlgebraOrthogonalBasis basis in the Lie algebra

\[X = \sum_{i∈\mathcal I} c_iB_i,\]

where $\{ B_i \}_{i∈\mathcal I}$ is a basis of the Lie algebra and $\mathcal I$ a corresponding index set, which is usually $\mathcal I=\{ 1,\ldots,n \}$.

The computation can be performed in-place of c. The inverse of vee is hat.

Technically, vee is a specific case of get_coordinates and is implemented using the LieAlgebraOrthogonalBasis

vee(G::LieGroup, X)
vee!(G::LieGroup, c, X)

Compute the vee map $(⋅)^∨$ that maps a tangent vector X from the LieAlgebra to its coordinates with respect to the LieAlgebraOrthogonalBasis basis in the Lie algebra

\[X = \sum_{i∈\mathcal I} c_iB_i,\]

where $\{ B_i \}_{i∈\mathcal I}$ is a basis of the Lie algebra and $\mathcal I$ a corresponding index set, which is usually $\mathcal I=\{ 1,\ldots,n \}$.

The computation can be performed in-place of c. The inverse of vee is hat.

Technically, vee is a specific case of get_coordinates and is implemented using the LieAlgebraOrthogonalBasis

rand(::LieGroup; vector_at=nothing, σ::Real=1.0, kwargs...)
rand(::LieAlgebra; σ::Real=1.0, kwargs...)
rand!(::LieGroup, gX; vector_at=nothing, σ::Real=1.0, kwargs...)
rand!(::LieAlgebra, X; σ::Real=1.0, kwargs...)

Compute a random point or tangent vector on a Lie group.

For points this just means to generate a random point on the underlying manifold itself.

For tangent vectors, an element in the Lie Algebra is generated, see also rand(::LieAlgebra; kwargs...)