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 conjutage $c_g(h) = g∘h∘g^{-1} = g+h-g = h$, which simplifies for AdditionGroupOperation to $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 conjutage $c_g(h) = g∘h∘g^{-1} = g+h-g = h$, which simplifies for AdditionGroupOperation to $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 $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 $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 left group multiplication $λ_g(h) = g∘h$, which simplifies for AdditionGroupOperation to $Dλ_g(h)[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 left group multiplication $λ_g(h) = g∘h$, which simplifies for AdditionGroupOperation to $Dλ_g(h)[X] = X$.

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

Compute the differential of the right group multiplication $ρ_g(h) = h∘g$, which simplifies for AdditionGroupOperation to $Dρ_g(h)[X] = X$.

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

Compute the differential of the right group multiplication $ρ_g(h) = h∘g$, which simplifies for AdditionGroupOperation to $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 AbstractMultiplicationGroupOperation to $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 AbstractMultiplicationGroupOperation to $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 $Dι_{\mathcal G}(g)[X]$ of matrix inversion $ι_{\mathcal G}(g) := g^{-1}$ at $X ∈ 𝔤$ in the LieAlgebra $𝔤$ of the LieGroup G.

The formula is given by

\[Dι_{\mathcal G}(g)[X] = -g^{\mathrm{T}}Xg^{-1},\]

which stems from using the differential of the inverse from [Gil08] given by $D(g^{-1})[X] = -g^{-1}Xg^{-1}$ composed with the push forward of the left composition $Dλ_\mathrm{e}(g)[X] = gX$ mapping from the Liea algebra into the tangent space at $g$, and its adjoint $D^*λ_\mathrm{e}(g)[X] = g^{\mathrm{T}}X$. Then we get $g^{\mathrm{T}}(g^{-1}(gX)g^{-1})$ which simplifies to $-g^{\mathrm{T}}Xg^{-1}$ from above.

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

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

The formula is given by

\[Dι_{\mathcal G}(g)[X] = -g^{\mathrm{T}}Xg^{-1},\]

which stems from using the differential of the inverse from [Gil08] given by $D(g^{-1})[X] = -g^{-1}Xg^{-1}$ composed with the push forward of the left composition $Dλ_\mathrm{e}(g)[X] = gX$ mapping from the Liea algebra into the tangent space at $g$, and its adjoint $D^*λ_\mathrm{e}(g)[X] = g^{\mathrm{T}}X$. Then we get $g^{\mathrm{T}}(g^{-1}(gX)g^{-1})$ which simplifies to $-g^{\mathrm{T}}Xg^{-1}$ from above.

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

Compute the differential of the left group multiplication $λ_g(h) = g∘h$, which simplifies for an AbstractMultiplicationGroupOperation to $Dλ_g(h)[X] = gX$.

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

Compute the differential of the left group multiplication $λ_g(h) = g∘h$, which simplifies for an AbstractMultiplicationGroupOperation to $Dλ_g(h)[X] = gX$.

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

Compute the differential of the right group multiplication $ρ_g(h) = h∘g$, which simplifies for an AbstractMultiplicationGroupOperation to $Dρ_g(h)[X] = Xg$.

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

Compute the differential of the right group multiplication $ρ_g(h) = h∘g$, which simplifies for an AbstractMultiplicationGroupOperation to $Dρ_g(h)[X] = Xg$.

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 $D(c_g(h))[X] = X$.

This can be computed in-place of Y if Y 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 $D(c_g(h))[X] = X$.

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

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

Compute the value of the differential $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

\[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 left group multiplication $λ_g(h) = g∘h$.

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 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 left group multiplication $λ_g(h) = g∘h$.

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 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 right group multiplication $ρ_g(h) = h∘g$.

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 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 right group multiplication $ρ_g(h) = h∘g$.

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 Y if Y 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.

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.