An interface for Lie algebras
LieGroups.LieAlgebra
β TypeLieAlgebra{π½, G} <: AbstractManifold{π½}
Represent the Lie algebra $\mathfrak g$, that is a $π½$ vector space with an associated lie_bracket
$[β
,β
]: \mathfrak gΓ\mathfrak g β \mathfrak g$ which fulfills
- $[X,X] = 0$ for all $X β \mathfrak g$
- The Jacobi identity $[X, [Y,Z]] = [[X,Y],Z] = [Y, [X,Z]]$ holds for all $X, Y, Z β \mathfrak g$.
The Lie algebras considered here are those related to a LieGroup
$\mathcal G$, namely the tangent space $T_{\mathrm{e}}\mathcal G$ at the Identity
, this is internally just a const
of the corresponding TangentSpace
.
A vector field $\mathcal X: \mathcal G β T\mathcal G$, $X(g) β T_g\mathcal G$ is called a left-invariant vector field if it satisfies
\[\mathcal X(Ξ»_g(h)) = DΞ»_g(h)[\mathcal X(h)], \quad\text{for all}\quad g, h β \mathcal G,\]
where $Ξ»_g: \mathcal G β \mathcal G$ is the left multiplication by $g$. Hence $\mathcal X$ is determined already when $X β \mathfrak g$ is given, since $\mathcal X(g) = DΞ»_g(e)[X]$, cf [HN12, Definition 9.1.7].
Throughout LieGroups.jl
, we use this left-invariant convention to store tangent vectors at points on a Lie group as elements of the corresponding Lie algebra.
Constructor
LieAlgebra(G::LieGroup)
Return the Lie Algebra belonging to the LieGroup
G
.
LieGroups.DefaultLieAlgebraOrthogonalBasis
β TypeDefaultLieAlgebraOrthogonalBasis{π½} <: ManifoldsBase.AbstractOrthogonalBasis{π½,ManifoldsBase.TangentSpaceType}
Specify an orthogonal basis for a Lie algebra. This is used as the default within hat
and vee
.
If not specifically overwritten/implemented for a Lie group, the DefaultOrthogonalBasis
at the identity_element
on the `base_manifold acts as a fallback.
In order to implement the corresponding get_coordinates
and get_vector
functions, define get_coordinates_lie(::LieGroup, p, X, B)
and get_vector_lie(::LieGroup, p, X, B)
, resp.
Functions on Lie algebras
Base.rand
β Methodrand(::LieGroup; vector_at=nothing, Ο=1.0, kwargs...)
rand(::LieAlgebra; Ο=1.0, kwargs...)
rand!(::LieGroup, gX; vector_at=nothing, kwargs...)
rand!(::LieAlgebra, X; Ο=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...)
LieGroups.base_lie_group
β Methodbase_lie_group(π€::LieAlgebra)
Return the base_lie_group
of the given LieAlgebra
belongs to.
LieGroups.lie_bracket!
β Methodlie_bracket!(π€::LieAlgebra, X, Y)
lie_bracket!(π€::LieAlgebra, Z, X, Y)
Compute the Lie bracket $[β ,β ]: \mathfrak gΓ\mathfrak g β \mathfrak g$ which fulfills
- $[X,X] = 0$ for all $X β \mathfrak g$
- The Jacobi identity $[X, [Y,Z]] = [[X,Y],Z] = [Y, [X,Z]]$ holds for all $X, Y, Z β \mathfrak g$.
The computation can be done in-place of Z
.
LieGroups.lie_bracket
β Methodlie_bracket!(π€::LieAlgebra, X, Y)
lie_bracket!(π€::LieAlgebra, Z, X, Y)
Compute the Lie bracket $[β ,β ]: \mathfrak gΓ\mathfrak g β \mathfrak g$ which fulfills
- $[X,X] = 0$ for all $X β \mathfrak g$
- The Jacobi identity $[X, [Y,Z]] = [[X,Y],Z] = [Y, [X,Z]]$ holds for all $X, Y, Z β \mathfrak g$.
The computation can be done in-place of Z
.
ManifoldsBase.base_manifold
β Methodbase_manifold(π€::LieAlgebra)
Return the base_manifold
the LieGroup
of the given LieAlgebra
is based on.
ManifoldsBase.get_coordinates
β Functionget_coordinates(π€::LieAlgebra, X::T, B::AbstractBasis)
get_coordinates!(π€::LieAlgebra, c, X::T, B::AbstractBasis)
Return the vector of coordinates to the decomposition of X
with respect to an AbstractBasis
of the LieAlgebra
π€
. The operation can be performed in-place of c
.
By default this function requires that identity_element
(G, T)
is available 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
.
ManifoldsBase.get_coordinates!
β Functionget_coordinates(π€::LieAlgebra, X::T, B::AbstractBasis)
get_coordinates!(π€::LieAlgebra, c, X::T, B::AbstractBasis)
Return the vector of coordinates to the decomposition of X
with respect to an AbstractBasis
of the LieAlgebra
π€
. The operation can be performed in-place of c
.
By default this function requires that identity_element
(G, T)
is available 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
.
ManifoldsBase.get_vector
β Functionget_vector(G::LieGroup, c, B::AbstractBasis; kwargs...)
get_vector(π€::LieAlgebra, c, B::AbstractBasis; kwargs...)
get_vector!(G::LieGroup, X::T, c, B::AbstractBasis; kwargs...)
get_vector!(π€::LieAlgebra, X::T, c, B::AbstractBasis; kwargs...)
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 equivalent. The operation can be performed in-place of a tangent vector X
of type ::T
.
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
.
Keyword arguments
tangent_vector_type
specify the tangent vector type to use for the allocating variants.
See also hat
ManifoldsBase.get_vector!
β Functionget_vector(G::LieGroup, c, B::AbstractBasis; kwargs...)
get_vector(π€::LieAlgebra, c, B::AbstractBasis; kwargs...)
get_vector!(G::LieGroup, X::T, c, B::AbstractBasis; kwargs...)
get_vector!(π€::LieAlgebra, X::T, c, B::AbstractBasis; kwargs...)
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 equivalent. The operation can be performed in-place of a tangent vector X
of type ::T
.
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
.
Keyword arguments
tangent_vector_type
specify the tangent vector type to use for the allocating variants.
See also hat
ManifoldsBase.hat!
β Methodhat(G::LieAlgebra, c)
hat(G::LieAlgebra, c, T::Type)
hat!(G::LieAlgebra, X::T, c)
Compute the hat map $(β )^Μ : \mathcal V β π€$ that maps a vector of coordinates $\mathbf{c} β \mathcal V$, to a tangent vector $X β \mathfrak g$. The coefficients are given with respect to a specific 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 \}$. Then $\mathcal V = β^n$.
For the allocating variant, you can specify the type T
of the tangent vector to obtain, in case there are different representations. The first signature produces the default representation.
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 DefaultLieAlgebraOrthogonalBasis
.
ManifoldsBase.hat
β Methodhat(G::LieAlgebra, c)
hat(G::LieAlgebra, c, T::Type)
hat!(G::LieAlgebra, X::T, c)
Compute the hat map $(β )^Μ : \mathcal V β π€$ that maps a vector of coordinates $\mathbf{c} β \mathcal V$, to a tangent vector $X β \mathfrak g$. The coefficients are given with respect to a specific 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 \}$. Then $\mathcal V = β^n$.
For the allocating variant, you can specify the type T
of the tangent vector to obtain, in case there are different representations. The first signature produces the default representation.
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 DefaultLieAlgebraOrthogonalBasis
.
ManifoldsBase.is_point
β Methodis_point(π€::LieAlgebra, X; kwargs...)
Check whether X
is a valid point on the Lie Algebra π€
. This falls back to checking whether X
is a valid point on the tangent space at the identity_element
(G)
on the base_manifold
(G)
on the LieGroup
of π€
ManifoldsBase.vee!
β Methodvee(π€::LieAlgebra, X)
vee!(π€::LieAlgebra, c, X)
Compute the vee map $(β
)^β¨: \mathfrak g β \mathcal V$ that maps a tangent vector X
from the LieAlgebra
\mathfrak g to its coordinates with respect to the DefaultLieAlgebraOrthogonalBasis
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 \}$. Then $\mathcal V = β^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 DefaultLieAlgebraOrthogonalBasis
.
ManifoldsBase.vee
β Methodvee(π€::LieAlgebra, X)
vee!(π€::LieAlgebra, c, X)
Compute the vee map $(β
)^β¨: \mathfrak g β \mathcal V$ that maps a tangent vector X
from the LieAlgebra
\mathfrak g to its coordinates with respect to the DefaultLieAlgebraOrthogonalBasis
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 \}$. Then $\mathcal V = β^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 DefaultLieAlgebraOrthogonalBasis
.
ManifoldsBase.zero_vector
β Methodzero_vector(π€::LieAlgebra)
zero_vector(π€::LieAlgebra, T::Type)
zero_vector!(π€::LieAlgebra, X::T)
Generate a zero_vector
of type T
in the LieAlgebra
$π€$ of the LieGroup
G
. By default this calls zero_vector
on the manifold of G
at the identity_element(G,T)
For the allocating variant the type T
of the zero vector can be specified.
Random.rand!
β Methodrand(::LieGroup; vector_at=nothing, Ο=1.0, kwargs...)
rand(::LieAlgebra; Ο=1.0, kwargs...)
rand!(::LieGroup, gX; vector_at=nothing, kwargs...)
rand!(::LieAlgebra, X; Ο=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...)
Internal functions and macros
LieGroups.@default_lie_algebra_fallbacks
β Macrodefault_lie_algebra_fallbacks(TG, TF, Op, TV, Xfield::Symbol)
Introduce default fallbacks for all basic functions on Lie algebras, for Lie group of type TG
with number system TF
, an group operation Op
, tangent vectors of type TV
, with forwarding to fields Xfield
and tangent vector functions
Literature
- [HN12]
- J.Β Hilgert and K.-H.Β Neeb. Structure and Geometry of Lie Groups (Springer Monographs in Mathematics, 2012).