lie_bracket and adjoint_action

docs/src/misc/notation.md

@@ -10,6 +10,7 @@ Within the documented functions, the utf8 symbols are used whenever possible, as
 | Symbol | Description | Also used | Comment |
 |:--:|:--------------- |:--:|:-- |
 | ``\tau_p`` | action map by group element ``p`` | ``\mathrm{L}_p``, ``\mathrm{R}_p`` | either left or right |
+| ``\operatorname{Ad}_p(X)`` | adjoint action of element ``p`` of a Lie group on the element ``X`` of the corresponding Lie algebra | | |
 | ``\times`` | Cartesian product of two manifolds | | see [`ProductManifold`](@ref) |
 | ``^{\wedge}`` | (n-ary) Cartesian power of a manifold | | see [`PowerManifold`](@ref) |
 | ``a`` | coordinates of a point in a chart | | see [`get_parameters`](@ref) |

src/Manifolds.jl

@@ -526,7 +526,9 @@ export AbstractGroupAction,
     SpecialOrthogonal,
     TranslationGroup,
     TranslationAction
-export affine_matrix,
+export adjoint_action,
+    adjoint_action!,
+    affine_matrix,
     apply,
     apply!,
     apply_diff,
@@ -557,6 +559,8 @@ export affine_matrix,
     inverse_translate!,
     inverse_translate_diff,
     inverse_translate_diff!,
+    lie_bracket,
+    lie_bracket!,
     make_identity,
     optimal_alignment,
     optimal_alignment!,

src/groups/array_manifold.jl

@@ -4,6 +4,24 @@ array_point(p) = ValidationMPoint(p)
 array_point(p::ValidationMPoint) = p
 array_point(e::Identity) = Identity(e.group, array_point(e.p))
 
+function adjoint_action(M::ValidationManifold, p, X; kwargs...)
+    is_point(M, p, true; kwargs...)
+    eM = make_identity(M.manifold, array_value(p))
+    is_vector(M, eM, X, true; kwargs...)
+    Y = ValidationTVector(adjoint_action(M.manifold, array_value(p), array_value(X)))
+    is_vector(M, eM, Y, true; kwargs...)
+    return Y
+end
+
+function adjoint_action!(M::ValidationManifold, Y, p, X; kwargs...)
+    is_point(M, p, true; kwargs...)
+    eM = make_identity(M.manifold, array_value(p))
+    is_vector(M, eM, X, true; kwargs...)
+    adjoint_action!(M.manifold, array_value(Y), array_value(p), array_value(X))
+    is_vector(M, eM, Y, true; kwargs...)
+    return Y
+end
+
 function Base.inv(M::ValidationManifold, p; kwargs...)
     is_point(M, p, true; kwargs...)
     q = array_point(inv(M.manifold, array_value(p)))
@@ -32,6 +50,24 @@ function identity!(M::ValidationManifold, q, p; kwargs...)
     return q
 end
 
+function lie_bracket(M::ValidationManifold, X, Y)
+    eM = make_identity(M.manifold, array_value(X))
+    is_vector(M, eM, X, true)
+    is_vector(M, eM, Y, true)
+    Z = ValidationTVector(lie_bracket(M.manifold, array_value(X), array_value(Y)))
+    is_vector(M, eM, Z, true)
+    return Z
+end
+
+function lie_bracket!(M::ValidationManifold, Z, X, Y)
+    eM = make_identity(M.manifold, array_value(X))
+    is_vector(M, eM, X, true)
+    is_vector(M, eM, Y, true)
+    lie_bracket!(M.manifold, array_value(Z), array_value(X), array_value(Y))
+    is_vector(M, eM, Z, true)
+    return Z
+end
+
 function compose(M::ValidationManifold, p, q; kwargs...)
     is_point(M, p, true; kwargs...)
     is_point(M, q, true; kwargs...)

src/groups/circle_group.jl

@@ -14,6 +14,13 @@ invariant_metric_dispatch(::CircleGroup, ::ActionDirection) = Val(true)
 
 default_metric_dispatch(::MetricManifold{ℂ,CircleGroup,EuclideanMetric}) = Val(true)
 
+adjoint_action(::CircleGroup, p, X) = X
+
+function adjoint_action!(::CircleGroup, Y, p, X)
+    copyto!(Y, X)
+    return Y
+end
+
 function compose(G::CircleGroup, p::AbstractVector, q::AbstractVector)
     return map(compose, repeated(G), p, q)
 end
@@ -46,6 +53,13 @@ function inverse_translate(
     return map(/, q, p)
 end
 
+lie_bracket(::CircleGroup, X, Y) = zero(X)
+
+function lie_bracket!(::CircleGroup, Z, X, Y)
+    fill(Z, 0)
+    return Z
+end
+
 translate_diff(::GT, p, q, X, ::ActionDirection) where {GT<:CircleGroup} = map(*, p, X)
 function translate_diff(
     ::GT,

src/groups/group.jl

@@ -363,6 +363,31 @@ end
 # Group-specific functions
 ##########################
 
+@doc raw"""
+    adjoint_action(G::AbstractGroupManifold, p, X)
+
+Adjoint action of the element `p` of the Lie group `G` on the element `X`
+of the corresponding Lie algebra.
+
+It is defined as the differential of the group authomorphism $Ψ_p(q) = pqp⁻¹$ at
+the identity of `G`.
+
+The formula reads
+````math
+\operatorname{Ad}_p(X) = dΨ_p(e)[X]
+````
+where $e$ is the identity element of `G`.
+"""
+adjoint_action(G::AbstractGroupManifold, p, X)
+@decorator_transparent_function :intransparent function adjoint_action(
+    G::AbstractGroupManifold,
+    p,
+    X,
+)
+    Y = allocate_result(G, adjoint_action, p)
+    return adjoint_action!(G, Y, p, X)
+end
+
 @doc raw"""
     inv(G::AbstractGroupManifold, p)
 
@@ -484,6 +509,18 @@ function decorator_transparent_dispatch(
     return Val(:intransparent)
 end
 
+"""
+    lie_bracket(G::AbstractGroupManifold, X, Y)
+
+Lie bracket between elements `X`, `Y` of the Lie algebra corresponding to the Lie group `G`.
+"""
+lie_bracket(G::AbstractGroupManifold, X, Y)
+@decorator_transparent_signature lie_bracket(M::AbstractDecoratorManifold, X, Y)
+function lie_bracket(G::AbstractGroupManifold, X, Y)
+    Z = allocate(G, lie_bracket, X, Y)
+    return lie_bracket!(G, Z, X, Y)
+end
+
 _action_order(p, q, conv::LeftAction) = (p, q)
 _action_order(p, q, conv::RightAction) = (q, p)
 
@@ -951,6 +988,13 @@ Base.:*(e::Identity{G}, p) where {G<:AdditionGroup} = e
 Base.:*(p, e::Identity{G}) where {G<:AdditionGroup} = e
 Base.:*(e::E, ::E) where {G<:AdditionGroup,E<:Identity{G}} = e
 
+adjoint_action(::AdditionGroup, p, X) = X
+
+function adjoint_action!(::AdditionGroup, Y, p, X)
+    copyto!(Y, X)
+    return Y
+end
+
 Base.zero(e::Identity{G}) where {G<:AdditionGroup} = e
 
 Base.identity(::AdditionGroup, p) = zero(p)
@@ -988,6 +1032,13 @@ group_log(::AdditionGroup, q) = q
 
 group_log!(::AdditionGroup, X, q) = copyto!(X, q)
 
+lie_bracket(::AdditionGroup, X, Y) = zero(X)
+
+function lie_bracket!(::AdditionGroup, Z, X, Y)
+    fill(Z, 0)
+    return Z
+end
+
 #######################################
 # Overloads for MultiplicationOperation
 #######################################
@@ -1015,6 +1066,13 @@ Base.:\(p, ::Identity{G}) where {G<:MultiplicationGroup} = inv(p)
 Base.:\(::Identity{G}, p) where {G<:MultiplicationGroup} = p
 Base.:\(e::E, ::E) where {G<:MultiplicationGroup,E<:Identity{G}} = e
 
+adjoint_action(G::MultiplicationGroup, p, X) = p * X / p
+
+function adjoint_action!(::MultiplicationGroup, Y, p, X)
+    copyto!(Y, p * X / p)
+    return Y
+end
+
 Base.inv(e::Identity{G}) where {G<:MultiplicationGroup} = e
 
 Base.one(e::Identity{G}) where {G<:MultiplicationGroup} = e
@@ -1062,3 +1120,10 @@ function group_exp!(G::MultiplicationGroup, q, X)
 end
 
 group_log!(::MultiplicationGroup, X::AbstractMatrix, q::AbstractMatrix) = log_safe!(X, q)
+
+lie_bracket(::MultiplicationGroup, X, Y) = X * Y - Y * X
+
+function lie_bracket!(::MultiplicationGroup, Z, X, Y)
+    copyto!(Z, X * Y - Y * X)
+    return Z
+end

src/groups/special_euclidean.jl

@@ -98,7 +98,14 @@ R & t \\
 \end{pmatrix}.
 ````
 
+This function embeds $\mathrm{SE}(n)$ in the general linear group $\mathrm{GL}(n+1)$.
+It is an isometric embedding and group homomorphism [^RicoMatrinex1988].
+
 See also [`screw_matrix`](@ref) for matrix representations of the Lie algebra.
+
+[^RicoMatrinex1988]:
+    > Rico Martinez, J. M., “Representations of the Euclidean group and its applications
+    > to the kinematics of spatial chains,” PhD Thesis, University of Florida, 1988.
 """
 function affine_matrix(G::SpecialEuclidean{n}, p) where {n}
     pis = submanifold_components(G, p)
@@ -128,6 +135,8 @@ the $n + 1 × n + 1$ matrix
 \end{pmatrix}.
 ````
 
+This function embeds $𝔰𝔢(n)$ in the general linear Lie algebra $𝔤𝔩(n+1)$.
+
 See also [`affine_matrix`](@ref) for matrix representations of the Lie group.
 """
 function screw_matrix(G::SpecialEuclidean{n}, X) where {n}