An interface for Lie group operations

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$.

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

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

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$.

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.

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$.

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.

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$.

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$.

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$

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$

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$.

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$.

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$.

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$.

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.

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.

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.

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.

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.

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.

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$.

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$.

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

MatrixMultiplicationGroupOperation <: AbstractMultiplicationGroupOperation

A group operation that is realised by a matrix multiplication.

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.

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.

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.

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

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

This can be computed in-place of k.

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}$.

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}$.

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.

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.

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.

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.

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$.

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$.

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.

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.

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.

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.

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

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

This can be computed in-place of k.

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.

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.

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.

AbelianMultiplicationGroupOperation <: AbstractMultiplicationGroupOperation

A group operation that is realised by an abelian multiplication.

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.

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}$.

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.

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.

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 X if X is mutable.

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.

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.

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.

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.

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.

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$.

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$.

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.

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}$.

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.

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.

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.

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.

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.

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.

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 X if X is mutable.