An interface for Lie group operations

LieGroups.AbstractGroupOperation — Type

AbstractGroupOperation

Represent a type of group operation for a AbstractLieGroup $\mathcal G$, that is a smooth binary operation $∘ : \mathcal G × \mathcal G → \mathcal G$ on elements of a Lie group $\mathcal G$.

source

LieGroups.Identity — Type

Identity{O<:AbstractGroupOperation}

Represent the group identity element $e ∈ \mathcal G$ on an AbstractLieGroup $\mathcal G$ with AbstractGroupOperation of type O.

Similar to the philosophy that points are agnostic of their group at hand, the identity does not store the group $\mathcal G$ it belongs to. However it depends on the type of the AbstractGroupOperation used.

See also identity_element on how to obtain the corresponding AbstractManifoldPoint or array representation.

Constructors

Identity(::AbstractLieGroup{𝔽,O}) where {𝔽,O<:AbstractGroupOperation}
Identity(o::AbstractGroupOperation)
Identity(::Type{AbstractGroupOperation})

create the identity of the corresponding subtype O<:AbstractGroupOperation

source

You can combine some specific group operations with one of several manifolds to form a Lie group. You can still define the corresponding functions generically for all groups with this group operation regardless of the manifold. The following sections collect these.

an AdditionGroupOperation
an AbelianMultiplicationGroupOperation and
a MatrixMultiplicationGroupOperation

Additive group operation

LieGroups.AdditionGroupOperation — Type

AdditionGroupOperation <: AbstractGroupOperation

A group operation that is realised introducing defaults that fall back to + and - being overloaded, for example _compose(G::LieGroup{𝔽,AdditionGroupOperation}, a, b) = a + b

source

Base.exp — Method

exp(G::LieGroup{𝔽,AdditionGroupOperation}, X)
exp!(G::LieGroup{𝔽,AdditionGroupOperation}, g, X)

Compute the Lie group exponential on a LieGroup with an AdditionGroupOperation. This can be computed in-place of g.

Since e is just the zero-element with respect to the corresponding +, the formula reads $g=0+X=X$.

source

Base.inv — Method

inv(G::LieGroup{𝔽,AdditionGroupOperation}, g)
inv!(G::LieGroup{𝔽,AdditionGroupOperation}, h, g)

Compute the inverse group element $g^{-1}$, which for the AdditionGroupOperation simplifies to $-g$. This can be done in-place of h.

source

Base.log — Method

log(G::LieGroup{𝔽,AdditionGroupOperation}, g)
log!(G::LieGroup{𝔽,AdditionGroupOperation}, X, g)

Compute the Lie group logarithm on a LieGroup with an AdditionGroupOperation. This can be computed in-place of X.

Since e is just the zero-element with respect to the corresponding +, the formula reads $X=g-0=g$.

source

LieGroups.compose! — Method

compose(G::LieGroup{𝔽,AdditionGroupOperation}, g, h)
compose!(G::LieGroup{𝔽,AdditionGroupOperation}, k, g, h)

Compute the group operation composition of g and h with respect to the AdditionGroupOperation on G, which falls back to calling g+h, where + is assumed to be overloaded accordingly.

This can be computed in-place of k.

source

LieGroups.compose — Method

compose(G::LieGroup{𝔽,AdditionGroupOperation}, g, h)
compose!(G::LieGroup{𝔽,AdditionGroupOperation}, k, g, h)

Compute the group operation composition of g and h with respect to the AdditionGroupOperation on G, which falls back to calling g+h, where + is assumed to be overloaded accordingly.

This can be computed in-place of k.

source

LieGroups.diff_conjugate! — Method

diff_conjugate(G::LieGroup{𝔽,AdditionGroupOperation}, g, h, X)
diff_conjugate!(G::LieGroup{𝔽,AdditionGroupOperation}, Y, g, h, X)

Compute the differential of the conjugate $c_g(h) = g∘h∘g^{-1} = g+h-g = h$, which simplifies for AdditionGroupOperation to $\mathrm{d}(c_g(h))[X] = X$.

source

LieGroups.diff_conjugate — Method

diff_conjugate(G::LieGroup{𝔽,AdditionGroupOperation}, g, h, X)
diff_conjugate!(G::LieGroup{𝔽,AdditionGroupOperation}, Y, g, h, X)

Compute the differential of the conjugate $c_g(h) = g∘h∘g^{-1} = g+h-g = h$, which simplifies for AdditionGroupOperation to $\mathrm{d}(c_g(h))[X] = X$.

source

LieGroups.diff_inv! — Method

diff_inv(G::LieGroup{𝔽,AdditionGroupOperation}, g, X)
diff_inv!(G::LieGroup{𝔽,AdditionGroupOperation}, Y, g, X)

Compute the differential of the inverse operation $ι_{\mathcal G}(g) = g^-1 = -g$, which simplifies for AdditionGroupOperation to $\mathrm{d}ι_{\mathcal G}(g)[X] = -X$

source

LieGroups.diff_inv — Method

diff_inv(G::LieGroup{𝔽,AdditionGroupOperation}, g, X)
diff_inv!(G::LieGroup{𝔽,AdditionGroupOperation}, Y, g, X)

Compute the differential of the inverse operation $ι_{\mathcal G}(g) = g^-1 = -g$, which simplifies for AdditionGroupOperation to $\mathrm{d}ι_{\mathcal G}(g)[X] = -X$

source

LieGroups.diff_left_compose! — Method

diff_left_compose(G::LieGroup{𝔽,AdditionGroupOperation}, g, h, X)
diff_left_compose!(G::LieGroup{𝔽,AdditionGroupOperation}, Y, g, h, X)

Compute the differential of the the group operation $g+h$ with respect to the left argument g. Here it simplifies for AdditionGroupOperation to $\mathrm{d}ρ_h(g)[X] = X$.

source

LieGroups.diff_left_compose — Method

diff_left_compose(G::LieGroup{𝔽,AdditionGroupOperation}, g, h, X)
diff_left_compose!(G::LieGroup{𝔽,AdditionGroupOperation}, Y, g, h, X)

Compute the differential of the the group operation $g+h$ with respect to the left argument g. Here it simplifies for AdditionGroupOperation to $\mathrm{d}ρ_h(g)[X] = X$.

source

LieGroups.diff_right_compose! — Method

diff_right_compose(G::LieGroup{𝔽,AdditionGroupOperation}, g, h, X)
diff_right_compose!(G::LieGroup{𝔽,AdditionGroupOperation}, Y, g, h, X)

Compute the differential of the group operation $g∘h$, on an AbstractLieGroup G with respect to its second (right) argument h.

Another interpretation is to consider a function where we do a fixed multiplication from the left with g. i.e. the left group multiplication function $λ_g(h) = g∘h$ (where the left refers to the fixed argument $g$.).

For the AdditionGroupOperation it reads $\mathrm{d}λ_g(h)[X] = X$.

source

LieGroups.diff_right_compose — Method

diff_right_compose(G::LieGroup{𝔽,AdditionGroupOperation}, g, h, X)
diff_right_compose!(G::LieGroup{𝔽,AdditionGroupOperation}, Y, g, h, X)

Compute the differential of the group operation $g∘h$, on an AbstractLieGroup G with respect to its second (right) argument h.

For the AdditionGroupOperation it reads $\mathrm{d}λ_g(h)[X] = X$.

source

LieGroups.identity_element! — Method

identity_element(G::LieGroup{𝔽,AdditionGroupOperation})
identity_element!(G::LieGroup{𝔽,AdditionGroupOperation}, e)

Return the a point representation of the Identity, which for the AdditionGroupOperation is the zero element or array.

source

LieGroups.identity_element — Method

identity_element(G::LieGroup{𝔽,AdditionGroupOperation})
identity_element!(G::LieGroup{𝔽,AdditionGroupOperation}, e)

Return the a point representation of the Identity, which for the AdditionGroupOperation is the zero element or array.

source

LieGroups.jacobian_exp! — Method

jacobian_exp(G::LieGroup{𝔽,AdditionGroupOperation}, X, ::DefaultLieAlgebraOrthogonalBasis)
jacobian_exp!(G::LieGroup{𝔽,AdditionGroupOperation}, J, X, ::DefaultLieAlgebraOrthogonalBasis)

Compute the Jacobian of the Lie group exponential in a basis of the Lie algebra on a LieGroup with an AdditionGroupOperation.

Since such a group is Abelian and flat, the differential of the exponential map is the identity, so $J = I_n$ for every $X$.

source

LieGroups.jacobian_exp — Method

jacobian_exp(G::LieGroup{𝔽,AdditionGroupOperation}, X, ::DefaultLieAlgebraOrthogonalBasis)
jacobian_exp!(G::LieGroup{𝔽,AdditionGroupOperation}, J, X, ::DefaultLieAlgebraOrthogonalBasis)

Compute the Jacobian of the Lie group exponential in a basis of the Lie algebra on a LieGroup with an AdditionGroupOperation.

Since such a group is Abelian and flat, the differential of the exponential map is the identity, so $J = I_n$ for every $X$.

source

LieGroups.lie_bracket! — Method

lie_bracket(𝔤::LieAlgebra{𝔽,AdditionGroupOperation}, X, Y)
lie_bracket!(𝔤::LieAlgebra{𝔽,AdditionGroupOperation}, Z, X, Y)

Compute the Lie bracket $[⋅,⋅]: \mathfrak g×\mathfrak g → \mathfrak g$, which for the for the AdditionGroupOperation simplifies to the corresponding zero_vector. The computation can be done in-place of Z.

source

LieGroups.lie_bracket — Method

lie_bracket(𝔤::LieAlgebra{𝔽,AdditionGroupOperation}, X, Y)
lie_bracket!(𝔤::LieAlgebra{𝔽,AdditionGroupOperation}, Z, X, Y)

source

Manifolds.inv! — Method

inv(G::LieGroup{𝔽,AdditionGroupOperation}, g)
inv!(G::LieGroup{𝔽,AdditionGroupOperation}, h, g)

Compute the inverse group element $g^{-1}$, which for the AdditionGroupOperation simplifies to $-g$. This can be done in-place of h.

source

ManifoldsBase.exp! — Method

exp(G::LieGroup{𝔽,AdditionGroupOperation}, X)
exp!(G::LieGroup{𝔽,AdditionGroupOperation}, g, X)

Compute the Lie group exponential on a LieGroup with an AdditionGroupOperation. This can be computed in-place of g.

Since e is just the zero-element with respect to the corresponding +, the formula reads $g=0+X=X$.

source

ManifoldsBase.log! — Method

log(G::LieGroup{𝔽,AdditionGroupOperation}, g)
log!(G::LieGroup{𝔽,AdditionGroupOperation}, X, g)

Compute the Lie group logarithm on a LieGroup with an AdditionGroupOperation. This can be computed in-place of X.

Since e is just the zero-element with respect to the corresponding +, the formula reads $X=g-0=g$.

source

Multiplication group operation

LieGroups.AbstractMultiplicationGroupOperation — Type

AbstractMultiplicationGroupOperation <: AbstractGroupOperation

A group operation that is realised introducing defaults that fall back to * being overloaded, for example _compose(G::LieGroup{𝔽,<:AbstractMultiplicationGroupOperation}, a, b) = a * b

source

LieGroups.MatrixMultiplicationGroupOperation — Type

MatrixMultiplicationGroupOperation <: AbstractMultiplicationGroupOperation

A group operation that is realised by a matrix multiplication.

source

Base.exp — Method

exp(G::LieGroup{𝔽,<:AbstractMultiplicationGroupOperation}, X)
exp!(G::LieGroup{𝔽,<:AbstractMultiplicationGroupOperation}, g, X)

Compute the Lie group exponential on a LieGroup with an AbstractMultiplicationGroupOperation, which simplifies to the matrix exponential.

This can be computed in-place of g.

source

Base.inv — Method

inv(G::LieGroup{𝔽,<:AbstractMultiplicationGroupOperation}, g)
inv!(G::LieGroup{𝔽,<:AbstractMultiplicationGroupOperation}, h, g)

Compute the inverse group element $g^{-1}$, which for an AbstractMultiplicationGroupOperation simplifies to the multiplicative inverse $g^{-1}$. This can be done in-place of h.

source

Base.log — Method

log(G::LieGroup{𝔽,<:AbstractMultiplicationGroupOperation}, g)
log!(G::LieGroup{𝔽,<:AbstractMultiplicationGroupOperation}, X, g)

Compute the Lie group logarithm on a LieGroup with a concrete instance of AbstractMultiplicationGroupOperation, which simplifies to the (matrix) logarithm.

This can be computed in-place of X.

source

LieGroups.compose! — Method

compose(G::LieGroup{𝔽,<:AbstractMultiplicationGroupOperation}, g, h)
compose!(G::LieGroup{𝔽,<:AbstractMultiplicationGroupOperation}, k, g, h)

Compute the group operation composition of g and h on an LieGroup G.

For an AbstractMultiplicationGroupOperation this falls back to calling g*h, where * is assumed to be overloaded accordingly.

This can be computed in-place of k.

source

LieGroups.compose — Method

compose(G::LieGroup{𝔽,<:AbstractMultiplicationGroupOperation}, g, h)
compose!(G::LieGroup{𝔽,<:AbstractMultiplicationGroupOperation}, k, g, h)

Compute the group operation composition of g and h on an LieGroup G.

For an AbstractMultiplicationGroupOperation this falls back to calling g*h, where * is assumed to be overloaded accordingly.

This can be computed in-place of k.

source

LieGroups.diff_conjugate! — Method

diff_conjugate(G::LieGroup{𝔽,<:AbstractMultiplicationGroupOperation}, g, h, X)
diff_conjugate!(G::LieGroup{𝔽,<:AbstractMultiplicationGroupOperation}, Y, g, h, X)

Compute the differential of the conjugate $c_g(h) = g∘h∘g^{-1} = ghg^{-1}$, which simplifies for an AbstractMultiplicationGroupOperationto $\mathrm{d}(c_g(h))[X] = gXg^{-1}$.

source

LieGroups.diff_conjugate — Method

diff_conjugate(G::LieGroup{𝔽,<:AbstractMultiplicationGroupOperation}, g, h, X)
diff_conjugate!(G::LieGroup{𝔽,<:AbstractMultiplicationGroupOperation}, Y, g, h, X)

Compute the differential of the conjugate $c_g(h) = g∘h∘g^{-1} = ghg^{-1}$, which simplifies for an AbstractMultiplicationGroupOperationto $\mathrm{d}(c_g(h))[X] = gXg^{-1}$.

source

LieGroups.diff_inv! — Method

diff_inv(G::LieGroup{𝔽, <:AbstractMultiplicationGroupOperation}, g, X)
diff_inv!(G::LieGroup{𝔽, <:AbstractMultiplicationGroupOperation}, Y, g, X)

Compute the value of differential $\mathrm{d}ι_{\mathcal G}(g)[X]$ of matrix inversion $ι_{\mathcal G}(g) := g^{-1}$ at $X ∈ 𝔤$ in the LieAlgebra $𝔤$ of the LieGroup G.

The (classical) differential $\mathrm{D}ι_{\mathcal G}(g): T_g\mathcal G → T_{g^{-1}}\mathcal G$ reads

\[ \mathrm{D}ι_{\mathcal G}(g)[W] = -g^{-1}Wg^{-1} = -Xg^{-1} = -g^{-1}(gXg^{-1}) = -g^{-1}\mathrm{Ad}(g)[X] = V ∈ T_{g^{-1}}\mathcal G,\]

see e.g. [Gil08]. To bring this back to the Lie algebra, we Write $V = g^{-1}Y ∈ T_{g^{-1}}\mathcal G$ for some $Y ∈ 𝔤$ and obtain

\[ \mathrm{d} ι_{\mathcal G}(g)[X] = -\mathrm{Ad}(g)[X] ∈ 𝔤,\]

where we use $\mathrm{d}$ to denote the differential in the Lie algebra.

source

LieGroups.diff_inv — Method

diff_inv(G::LieGroup{𝔽, <:AbstractMultiplicationGroupOperation}, g, X)
diff_inv!(G::LieGroup{𝔽, <:AbstractMultiplicationGroupOperation}, Y, g, X)

Compute the value of differential $\mathrm{d}ι_{\mathcal G}(g)[X]$ of matrix inversion $ι_{\mathcal G}(g) := g^{-1}$ at $X ∈ 𝔤$ in the LieAlgebra $𝔤$ of the LieGroup G.

The (classical) differential $\mathrm{D}ι_{\mathcal G}(g): T_g\mathcal G → T_{g^{-1}}\mathcal G$ reads

\[ \mathrm{D}ι_{\mathcal G}(g)[W] = -g^{-1}Wg^{-1} = -Xg^{-1} = -g^{-1}(gXg^{-1}) = -g^{-1}\mathrm{Ad}(g)[X] = V ∈ T_{g^{-1}}\mathcal G,\]

see e.g. [Gil08]. To bring this back to the Lie algebra, we Write $V = g^{-1}Y ∈ T_{g^{-1}}\mathcal G$ for some $Y ∈ 𝔤$ and obtain

\[ \mathrm{d} ι_{\mathcal G}(g)[X] = -\mathrm{Ad}(g)[X] ∈ 𝔤,\]

where we use $\mathrm{d}$ to denote the differential in the Lie algebra.

source

LieGroups.diff_left_compose! — Method

diff_left_compose(G::LieGroup{𝔽,<:AbstractMultiplicationGroupOperation}, g, h, X)
diff_left_compose!(G::LieGroup{𝔽,<:AbstractMultiplicationGroupOperation}, Y, g, h, X)

Compute the differential of the group operation $g∘h$, on an AbstractLieGroup G with respect to its first (left) argument g.

Another interpretation is to consider a function where we do a fixed multiplication from the right with h. i..e. the right group multiplication function $ρ_h(g) = g∘h$.

The differential simplifies for an AbstractMultiplicationGroupOperation to

\[\mathrm{d} ρ_h(g)[X] = h^{-1}Xh = \mathrm{Ad}(h^{-1})[X] ∈ 𝔤,\]

where $\mathrm{Ad}$ denotes the adjoint.

source

LieGroups.diff_left_compose — Method

diff_left_compose(G::LieGroup{𝔽,<:AbstractMultiplicationGroupOperation}, g, h, X)
diff_left_compose!(G::LieGroup{𝔽,<:AbstractMultiplicationGroupOperation}, Y, g, h, X)

Compute the differential of the group operation $g∘h$, on an AbstractLieGroup G with respect to its first (left) argument g.

Another interpretation is to consider a function where we do a fixed multiplication from the right with h. i..e. the right group multiplication function $ρ_h(g) = g∘h$.

The differential simplifies for an AbstractMultiplicationGroupOperation to

\[\mathrm{d} ρ_h(g)[X] = h^{-1}Xh = \mathrm{Ad}(h^{-1})[X] ∈ 𝔤,\]

where $\mathrm{Ad}$ denotes the adjoint.

source

LieGroups.diff_right_compose! — Method

diff_right_compose(G::LieGroup{𝔽,<:AbstractMultiplicationGroupOperation}, g, h, X)
diff_right_compose!(G::LieGroup{𝔽,<:AbstractMultiplicationGroupOperation}, Y, g, h, X)

Compute the differential of the group operation $g∘h$, on an AbstractLieGroup G with respect to its second (right) argument h.

Another interpretation is to consider a function where we do a fixed multiplication from the left with g. i..e. the left group multiplication function $λ_g(h) = g∘h$.

It reads for an AbstractMultiplicationGroupOperation $\mathrm{d}λ_g(h)[X] = X$.

source

LieGroups.diff_right_compose — Method

diff_right_compose(G::LieGroup{𝔽,<:AbstractMultiplicationGroupOperation}, g, h, X)
diff_right_compose!(G::LieGroup{𝔽,<:AbstractMultiplicationGroupOperation}, Y, g, h, X)

Compute the differential of the group operation $g∘h$, on an AbstractLieGroup G with respect to its second (right) argument h.

Another interpretation is to consider a function where we do a fixed multiplication from the left with g. i..e. the left group multiplication function $λ_g(h) = g∘h$.

It reads for an AbstractMultiplicationGroupOperation $\mathrm{d}λ_g(h)[X] = X$.

source

LieGroups.identity_element! — Method

identity_element(G::LieGroup{𝔽,<:AbstractMultiplicationGroupOperation})
identity_element!(G::LieGroup{𝔽,<:AbstractMultiplicationGroupOperation}, e)

Return the a point representation of the Identity, which for an AbstractMultiplicationGroupOperation is the one-element or identity array.

source

LieGroups.identity_element — Method

identity_element(G::LieGroup{𝔽,<:AbstractMultiplicationGroupOperation})
identity_element!(G::LieGroup{𝔽,<:AbstractMultiplicationGroupOperation}, e)

Return the a point representation of the Identity, which for an AbstractMultiplicationGroupOperation is the one-element or identity array.

source

LieGroups.lie_bracket! — Method

lie_bracket(::LieAlgebra{𝔽,MatrixMultiplicationGroupOperation}, X, Y)
lie_bracket!(::LieAlgebra{𝔽,MatrixMultiplicationGroupOperation}, Z, X, Y)

Compute the Lie bracket $[⋅,⋅]: \mathfrak g×\mathfrak g → \mathfrak g$, which for the for the MatrixMultiplicationGroupOperation yields the commutator bracket

\[[X, Y] = XY-YX\]

The computation can be done in-place of Z.

source

LieGroups.lie_bracket — Method

lie_bracket(::LieAlgebra{𝔽,MatrixMultiplicationGroupOperation}, X, Y)
lie_bracket!(::LieAlgebra{𝔽,MatrixMultiplicationGroupOperation}, Z, X, Y)

Compute the Lie bracket $[⋅,⋅]: \mathfrak g×\mathfrak g → \mathfrak g$, which for the for the MatrixMultiplicationGroupOperation yields the commutator bracket

\[[X, Y] = XY-YX\]

The computation can be done in-place of Z.

source

Manifolds.inv! — Method

inv(G::LieGroup{𝔽,<:AbstractMultiplicationGroupOperation}, g)
inv!(G::LieGroup{𝔽,<:AbstractMultiplicationGroupOperation}, h, g)

Compute the inverse group element $g^{-1}$, which for an AbstractMultiplicationGroupOperation simplifies to the multiplicative inverse $g^{-1}$. This can be done in-place of h.

source

ManifoldsBase.exp! — Method

exp(G::LieGroup{𝔽,<:AbstractMultiplicationGroupOperation}, X)
exp!(G::LieGroup{𝔽,<:AbstractMultiplicationGroupOperation}, g, X)

Compute the Lie group exponential on a LieGroup with an AbstractMultiplicationGroupOperation, which simplifies to the matrix exponential.

This can be computed in-place of g.

source

ManifoldsBase.log! — Method

log(G::LieGroup{𝔽,<:AbstractMultiplicationGroupOperation}, g)
log!(G::LieGroup{𝔽,<:AbstractMultiplicationGroupOperation}, X, g)

Compute the Lie group logarithm on a LieGroup with a concrete instance of AbstractMultiplicationGroupOperation, which simplifies to the (matrix) logarithm.

This can be computed in-place of X.

source

Abelian multiplication group operation

Since the commutativity of some Lie groups leads to a significant simplification of computations on those groups, the abelian multiplication group operation optimizes these cases. Additionally, it provides an interface for the abelian Lie groups. Some of these can are represented by isbits-types, which don't have mutating variants of the functions.

LieGroups.AbelianMultiplicationGroupOperation — Type

AbelianMultiplicationGroupOperation <: AbstractMultiplicationGroupOperation

A group operation that is realised by an abelian multiplication.

source

Base.exp — Method

exp(G::LieGroup{𝔽,<:AbelianMultiplicationGroupOperation}, X)
exp(G::LieGroup{𝔽,<:AbelianMultiplicationGroupOperation}, g, X)
exp!(G::LieGroup{𝔽,<:AbelianMultiplicationGroupOperation}, h, X)
exp!(G::LieGroup{𝔽,<:AbelianMultiplicationGroupOperation}, h, g, X)

Compute the Lie group exponential on a LieGroup at a point g or the Identity with an AbelianMultiplicationGroupOperation.

Due to differences in the representation of some abelian Lie groups, this method wraps a concrete implementation of a specific abelian LieGroup with inputs of type AbstractArray{<:Any,0} and supports in-place computation.

This can be computed in-place of h if h is mutable.

source

Base.inv — Method

inv(G::LieGroup{𝔽,<:AbstractMultiplicationGroupOperation}, g)
inv!(G::LieGroup{𝔽,<:AbstractMultiplicationGroupOperation}, h, g)

Compute the inverse group element $g^{-1}$, which for the AbelianMultiplicationGroupOperation simplifies for a scalar input to the ordinary scalar inverse $g^{-1}$.

This can be computed in-place of h if h is mutable.

source

Base.log — Method

log(G::LieGroup{𝔽,<:AbelianMultiplicationGroupOperation}, h)
log(G::LieGroup{𝔽,<:AbelianMultiplicationGroupOperation}, g, h)
log!(G::LieGroup{𝔽,<:AbeliantMultiplicationGroupOperation}, X, g)
log!(G::LieGroup{𝔽,<:AbeliantMultiplicationGroupOperation}, X, g, h)

Compute the Lie group logarithm on a LieGroup at a point g or the Identity with a concrete instance of AbelianMultiplicationGroupOperation.

This can be computed in-place of X if X is mutable.

source

LieGroups.diff_conjugate! — Method

diff_conjugate(G::LieGroup{𝔽,<:AbelianMultiplicationGroupOperation}, g, h, X)
diff_conjugate!(G::LieGroup{𝔽,<:AbelianMultiplicationGroupOperation}, Y, g, h, X)

Compute the differential of the conjugate $c_g(h) = g∘h∘g^{-1} = ghg^{-1}$, which simplifies for an AbelianMultiplicationGroupOperation to $\mathrm{d}(c_g(h))[X] = X$.

This can be computed in-place of Y.

source

LieGroups.diff_conjugate — Method

diff_conjugate(G::LieGroup{𝔽,<:AbelianMultiplicationGroupOperation}, g, h, X)
diff_conjugate!(G::LieGroup{𝔽,<:AbelianMultiplicationGroupOperation}, Y, g, h, X)

Compute the differential of the conjugate $c_g(h) = g∘h∘g^{-1} = ghg^{-1}$, which simplifies for an AbelianMultiplicationGroupOperation to $\mathrm{d}(c_g(h))[X] = X$.

This can be computed in-place of Y.

source

LieGroups.diff_inv! — Method

diff_inv(G::LieGroup{𝔽,<:AbelianMultiplicationGroupOperation}, g, X)
diff_inv!(G::LieGroup{𝔽,<:AbelianMultiplicationGroupOperation}, Y, g, X)

Compute the value of the differential $\mathrm{d}ι_{\mathcal G}(g)[X]$ of the inversion $ι_{\mathcal G}(g) := g^{-1}$ at $X ∈ 𝔤$ in the LieAlgebra $𝔤$ of the LieGroup G.

In the Abelian case, the computation simplifies to

\[\mathrm{d}ι_{\mathcal G}(g)[X] = -gXg^{-1} = -X.\]

This can be computed in-place of Y if Y is mutable.

source

LieGroups.diff_left_compose! — Method

diff_left_compose(G::LieGroup{𝔽,<:AbelianMultiplicationGroupOperation}, g, h, X)
diff_left_compose!(G::LieGroup{𝔽,<:AbelianMultiplicationGroupOperation}, Y, g, h, X)

Compute the differential of the group operation $g∘h$, on an AbstractLieGroup G with respect to its first (left) argument g.

Another interpretation is to consider a function where we do a fixed multiplication from the right with h. i..e. the right group multiplication function $ρ_h(g) = g∘h$.

The differential simplifies for an AbelianMultiplicationGroupOperation to the identity, i.e. $\mathrm{d}ρ_h(g)[X] = X$.

This can be computed in-place of Y if Y is mutable.

source

LieGroups.diff_left_compose — Method

diff_left_compose(G::LieGroup{𝔽,<:AbelianMultiplicationGroupOperation}, g, h, X)
diff_left_compose!(G::LieGroup{𝔽,<:AbelianMultiplicationGroupOperation}, Y, g, h, X)

Compute the differential of the group operation $g∘h$, on an AbstractLieGroup G with respect to its first (left) argument g.

Another interpretation is to consider a function where we do a fixed multiplication from the right with h. i..e. the right group multiplication function $ρ_h(g) = g∘h$.

The differential simplifies for an AbelianMultiplicationGroupOperation to the identity, i.e. $\mathrm{d}ρ_h(g)[X] = X$.

This can be computed in-place of Y if Y is mutable.

source

LieGroups.diff_right_compose! — Method

diff_right_compose(G::LieGroup{𝔽,<:AbelianMultiplicationGroupOperation}, g, h, X)
diff_right_compose!(G::LieGroup{𝔽,<:AbelianMultiplicationGroupOperation}, Y, g, h, X)

Compute the differential of the group operation $g∘h$, on an AbstractLieGroup G with respect to its second (right) argument h.

Another interpretation is to consider a function where we do a fixed multiplication from the left with g. i..e. the left group multiplication function $λ_g(h) = g∘h$.

The differential simplifies for an AbelianMultiplicationGroupOperation to the identity, i.e. $\mathrm{d}λ_g(h)[X] = X$.

source

LieGroups.diff_right_compose — Method

diff_right_compose(G::LieGroup{𝔽,<:AbelianMultiplicationGroupOperation}, g, h, X)
diff_right_compose!(G::LieGroup{𝔽,<:AbelianMultiplicationGroupOperation}, Y, g, h, X)

Compute the differential of the group operation $g∘h$, on an AbstractLieGroup G with respect to its second (right) argument h.

Another interpretation is to consider a function where we do a fixed multiplication from the left with g. i..e. the left group multiplication function $λ_g(h) = g∘h$.

The differential simplifies for an AbelianMultiplicationGroupOperation to the identity, i.e. $\mathrm{d}λ_g(h)[X] = X$.

source

LieGroups.identity_element! — Method

identity_element(G::LieGroup{𝔽,AbelianMultiplicationGroupOperation})
identity_element!(G::LieGroup{𝔽,AbelianMultiplicationGroupOperation}, e)

Return the point representation of the Identity, which for an AbelianMultiplicationGroupOperation is the one-element.

This can be computed in e if e is mutable.

source

LieGroups.identity_element — Method

identity_element(G::LieGroup{𝔽,AbelianMultiplicationGroupOperation})
identity_element!(G::LieGroup{𝔽,AbelianMultiplicationGroupOperation}, e)

Return the point representation of the Identity, which for an AbelianMultiplicationGroupOperation is the one-element.

This can be computed in e if e is mutable.

source

LieGroups.lie_bracket! — Method

lie_bracket(::LieAlgebra{𝔽,AbelianMultiplicationGroupOperation}, X, Y)
lie_bracket!(::LieAlgebra{𝔽,AbelianMultiplicationGroupOperation}, Z, X, Y)

Compute the Lie bracket $[⋅,⋅]: \mathfrak g×\mathfrak g → \mathfrak g$, which for the for the AbelianMultiplicationGroupOperation yields the zero vector of the LieAlgebra due to commutativity.

\[[X, Y] = XY-YX = 0\]

The computation can be done in-place of Z if Z is mutable.

source

LieGroups.lie_bracket — Method

lie_bracket(::LieAlgebra{𝔽,AbelianMultiplicationGroupOperation}, X, Y)
lie_bracket!(::LieAlgebra{𝔽,AbelianMultiplicationGroupOperation}, Z, X, Y)

\[[X, Y] = XY-YX = 0\]

The computation can be done in-place of Z if Z is mutable.

source

Manifolds.inv! — Method

inv(G::LieGroup{𝔽,<:AbstractMultiplicationGroupOperation}, g)
inv!(G::LieGroup{𝔽,<:AbstractMultiplicationGroupOperation}, h, g)

Compute the inverse group element $g^{-1}$, which for the AbelianMultiplicationGroupOperation simplifies for a scalar input to the ordinary scalar inverse $g^{-1}$.

This can be computed in-place of h if h is mutable.

source

ManifoldsBase.exp! — Method

exp(G::LieGroup{𝔽,<:AbelianMultiplicationGroupOperation}, X)
exp(G::LieGroup{𝔽,<:AbelianMultiplicationGroupOperation}, g, X)
exp!(G::LieGroup{𝔽,<:AbelianMultiplicationGroupOperation}, h, X)
exp!(G::LieGroup{𝔽,<:AbelianMultiplicationGroupOperation}, h, g, X)

Compute the Lie group exponential on a LieGroup at a point g or the Identity with an AbelianMultiplicationGroupOperation.

This can be computed in-place of h if h is mutable.

source

ManifoldsBase.log! — Method

log(G::LieGroup{𝔽,<:AbelianMultiplicationGroupOperation}, h)
log(G::LieGroup{𝔽,<:AbelianMultiplicationGroupOperation}, g, h)
log!(G::LieGroup{𝔽,<:AbeliantMultiplicationGroupOperation}, X, g)
log!(G::LieGroup{𝔽,<:AbeliantMultiplicationGroupOperation}, X, g, h)

Compute the Lie group logarithm on a LieGroup at a point g or the Identity with a concrete instance of AbelianMultiplicationGroupOperation.

This can be computed in-place of X if X is mutable.

source

Literature

[Gil08]: M. B. Giles. Collected Matrix Derivative Results for Forward and Reverse Mode Algorithmic Differentiation. In: Advances in Automatic Differentiation, Lecture Notes in Computational Science and Engineering, edited by C. H. Bischof, H. M. Bücker, P. Hovland, U. Naumann and J. Utke (Springer, Berlin, Heidelberg, 2008); pp. 35–44.