Settings
This document was generated with Documenter.jl version 1.7.0 on Wednesday 9 October 2024. Using Julia version 1.10.5.
Settings
This document was generated with Documenter.jl version 1.7.0 on Friday 11 October 2024. Using Julia version 1.10.5.
LieGroups.jlFirst, thanks for taking the time to contribute. Any contribution is appreciated and welcome.
The following is a set of guidelines to LieGroups.jl.
The developer can most easily be reached in the Julia Slack channel #manifolds. You can apply for the Julia Slack workspace here if you haven't joined yet. You can also ask your question on discourse.julialang.org.
If you found a bug or want to propose a feature, please open an issue in within the GitHub repository.
Currently we are still consolidating most details and defaults, but feel free to contribute to these discussions within this repository.
Try to follow the documentation guidelines from the Julia documentation as well as Blue Style. Run JuliaFormatter.jl on the repository in the way set in the .JuliaFormatter.toml file, which enforces a number of conventions consistent with the Blue Style. Furthermore vale is run on both Markdown and code files, affecting documentation and source code comments
Please follow a few internal conventions:
AbstractManoptProblem's struct contains information about the general structure of the problem.AbstractManoptProblem and helping functions are stored within the plan/ folder and sorted by properties of the problem and/or solver at hand.= signs.import/using/include should be in the main module file.Concerning documentation
If you implement an algorithm with a certain numerical example in mind, it would be great, if this could be added to the ManoptExamples.jl package as well.
Settings
This document was generated with Documenter.jl version 1.7.0 on Wednesday 9 October 2024. Using Julia version 1.10.5.
LieGroups.jlFirst, thanks for taking the time to contribute. Any contribution is appreciated and welcome.
The following is a set of guidelines to LieGroups.jl.
The developer can most easily be reached in the Julia Slack channel #manifolds. You can apply for the Julia Slack workspace here if you haven't joined yet. You can also ask your question on discourse.julialang.org.
If you found a bug or want to propose a feature, please open an issue in within the GitHub repository.
Currently we are still consolidating most details and defaults, but feel free to contribute to these discussions within this repository.
Try to follow the documentation guidelines from the Julia documentation as well as Blue Style. Run JuliaFormatter.jl on the repository in the way set in the .JuliaFormatter.toml file, which enforces a number of conventions consistent with the Blue Style.
Please follow a few internal conventions:
= signs.import/using/include should be in the main module file.import is discouraged and the explicit full name, like Base.exp should be used when implementing functionsConcerning documentation
Settings
This document was generated with Documenter.jl version 1.7.0 on Friday 11 October 2024. Using Julia version 1.10.5.
| Group | Manifold | $∘$ | Comment |
|---|---|---|---|
TranslationGroup | Euclidean | + |
Settings
This document was generated with Documenter.jl version 1.7.0 on Wednesday 9 October 2024. Using Julia version 1.10.5.
| Group | Manifold | $∘$ | Comment |
|---|---|---|---|
TranslationGroup | Euclidean | + |
Settings
This document was generated with Documenter.jl version 1.7.0 on Friday 11 October 2024. Using Julia version 1.10.5.
LieGroups.TranslationGroup — TypeTranslationGroup{𝔽}The Lie group consisting of the AdditionGroupOperation on some Euclidean space.
Constructor
TODO
Settings
This document was generated with Documenter.jl version 1.7.0 on Wednesday 9 October 2024. Using Julia version 1.10.5.
LieGroups.TranslationGroup — TypeTranslationGroup{𝔽}The Lie group consisting of the AdditionGroupOperation on some Euclidean space.
Constructor
TODO
Settings
This document was generated with Documenter.jl version 1.7.0 on Friday 11 October 2024. Using Julia version 1.10.5.
Welcome to the Documentation of LieGroups.jl.
Settings
This document was generated with Documenter.jl version 1.7.0 on Wednesday 9 October 2024. Using Julia version 1.10.5.
Welcome to the Documentation of LieGroups.jl.
Settings
This document was generated with Documenter.jl version 1.7.0 on Friday 11 October 2024. Using Julia version 1.10.5.
LieGroups.LieGroup — TypeLieGroup{𝔽,M<:AbstractManifold{𝔽}, O<:AbstractGroupOperation}Represent a Lie Group $\mathcal G$.
A Lie Group $\mathcal G$ is a group endowed with the structure of a manifold such that the group operations $∘: \mathcal G×\mathcal G → \mathcal G$, see compose and the inverse operation $⋅^{-1}: \mathcal G → \mathcal G$, see inv are smooth, see for example [HN12, Definition 9.1.1].
Lie groups are named after the Norwegian mathematician Marius Sophus Lie (1842–1899).
Fields
manifold: an AbstractManifold $\mathcal M$op: an AbstractGroupOperation $∘$ on that manifoldConstructor
LieGroup(M::AbstractManifold, op::AbstractGroupOperation; vectors=LeftInvariantRepresentation())Generate a Lie group based on a manifold M and a group operation op, where vectors by default are stored in the Lie Algebra.
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
The Lie algebras considered here are those related to a LieGroup $\mathcal G$, namely the tangent space the tangent space $T_{\mathrm e}\mathcal G$ at the Identity, this is internally just a const of the corresponding TangentSpace.
Constructor
LieAlgebra(G::LieGroup)Return the Lie Algebra belonging to the LieGroup G.
LieGroups.AbstractGroupOperation — TypeAbstractGroupOperationRepresent a type of group operation for a LieGroup $\mathcal G$, that is a smooth binary operation $∘ : \mathcal G × \mathcal G → \mathcal G$ on elements of a Lie group $\mathcal G$.
LieGroups.Identity — TypeIdentity{O<:AbstractGroupOperation}Represent the group identity element $e ∈ \mathcal G$ on a LieGroup $\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(::LieGroup{𝔽,M,O}) where {𝔽,M,O<:AbstractGroupOperation}
+An Interface for Lie Groups · LieGroups.jl The interface for Lie Groups
LieGroups.LieGroup — TypeLieGroup{𝔽,M<:AbstractManifold{𝔽}, O<:AbstractGroupOperation}
Represent a Lie Group $\mathcal G$.
A Lie Group $\mathcal G$ is a group endowed with the structure of a manifold such that the group operations $∘: \mathcal G×\mathcal G → \mathcal G$, see compose and the inverse operation $⋅^{-1}: \mathcal G → \mathcal G$, see inv are smooth, see for example [HN12, Definition 9.1.1].
Lie groups are named after the Norwegian mathematician Marius Sophus Lie (1842–1899).
Fields
manifold: an AbstractManifold $\mathcal M$op: an AbstractGroupOperation $∘$ on that manifold
Constructor
LieGroup(M::AbstractManifold, op::AbstractGroupOperation; vectors=LeftInvariantRepresentation())
Generate a Lie group based on a manifold M and a group operation op, where vectors by default are stored in the Lie Algebra.
sourceLieGroups.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 holds $[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 the tangent space $T_{\mathrm e}\mathcal G$ at the Identity, this is internally just a const of the corresponding TangentSpace.
Constructor
LieAlgebra(G::LieGroup)
Return the Lie Algebra belonging to the LieGroup G.
sourceGroup Operations
LieGroups.AbstractGroupOperation — TypeAbstractGroupOperation
Represent a type of group operation for a LieGroup $\mathcal G$, that is a smooth binary operation $∘ : \mathcal G × \mathcal G → \mathcal G$ on elements of a Lie group $\mathcal G$.
sourceLieGroups.Identity — TypeIdentity{O<:AbstractGroupOperation}
Represent the group identity element $e ∈ \mathcal G$ on a LieGroup $\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(::LieGroup{𝔽,M,O}) where {𝔽,M,O<:AbstractGroupOperation}
Identity(o::AbstractGroupOperation)
-Identity(::Type{AbstractGroupOperation})
create the identity of the corresponding subtype O<:AbstractGroupOperation
sourceFunctions on Lie Groups
Base.adjoint — Functionadjoint(G::LieGroup, g X)
-adjoint!(G::LieGroup, Y, g, X)
Compute the adjoint $\mathrm{Ad}(g): \mathfrak g → \mathfrak g$, which is defined as the differential diff_conjugate of the conjugate $c_g(h) = g∘h∘g^{-1}$ evaluated at the Identity $h=\mathrm e$. The operation can be performed in-place of Y.
\[ \mathrm{Ad}(g)[X] = D c_g(\mathrm e) [X], \qquad X ∈ \mathfrak g.\]
see [HN12, Section 9.2.3].
On matrix Lie groups the adjoint reads $\mathrm{Ad}(g)[X] = g∘X∘g^{-1}$.
sourceLieGroups.adjoint! — Functionadjoint(G::LieGroup, g X)
-adjoint!(G::LieGroup, Y, g, X)
Compute the adjoint $\mathrm{Ad}(g): \mathfrak g → \mathfrak g$, which is defined as the differential diff_conjugate of the conjugate $c_g(h) = g∘h∘g^{-1}$ evaluated at the Identity $h=\mathrm e$. The operation can be performed in-place of Y.
\[ \mathrm{Ad}(g)[X] = D c_g(\mathrm e) [X], \qquad X ∈ \mathfrak g.\]
see [HN12, Section 9.2.3].
On matrix Lie groups the adjoint reads $\mathrm{Ad}(g)[X] = g∘X∘g^{-1}$.
sourceManifoldsBase.base_manifold — Functionbase_manifold(G::LieGroup)
Return the manifold stored within the LieGroup G.
sourcebase_manifold(A::AbstractGroupAction)
Return the AbstractManifold of the AbstractGroupAction.
sourceLieGroups.compose — Functioncompose(G::LieGroup, g, h)
-compose!(G::LieGroup, k, g, h)
Perform the group oepration $g ∘ h$ for two $g, h ∈ \mathcal G$ on the LieGroup G. This can also be done in-place of h.
sourceLieGroups.compose! — Functioncompose(G::LieGroup, g, h)
-compose!(G::LieGroup, k, g, h)
Perform the group oepration $g ∘ h$ for two $g, h ∈ \mathcal G$ on the LieGroup G. This can also be done in-place of h.
sourceLieGroups.diff_left_compose — Functiondiff_left_compose(G::LieGroup, g, h, X)
-diff_left_compose!(G::LieGroup, Y, g, h, X)
Compute the differential of the left group multiplication $λ_g(h) = g∘h$, on the LieGroup G, that is Compute $Dλ_g(h)[X]$, $X ∈ 𝔤$. This can be done in-place of Y.
sourceLieGroups.diff_left_compose! — Functiondiff_left_compose(G::LieGroup, g, h, X)
-diff_left_compose!(G::LieGroup, Y, g, h, X)
Compute the differential of the left group multiplication $λ_g(h) = g∘h$, on the LieGroup G, that is Compute $Dλ_g(h)[X]$, $X ∈ 𝔤$. This can be done in-place of Y.
sourceLieGroups.diff_right_compose — Functiondiff_right_compose(G::LieGroup, h, g, X)
-diff_right_compose!(G::LieGroup, Y, h, g, X)
Compute the differential of the right group multiplication $ρ_g(h) = h∘g$, on the LieGroup G, that is Compute $Dρ_g(h)[X]$, $X ∈ 𝔤$ This can be done in-place of Y.
sourceLieGroups.diff_right_compose! — Functiondiff_right_compose(G::LieGroup, h, g, X)
-diff_right_compose!(G::LieGroup, Y, h, g, X)
Compute the differential of the right group multiplication $ρ_g(h) = h∘g$, on the LieGroup G, that is Compute $Dρ_g(h)[X]$, $X ∈ 𝔤$ This can be done in-place of Y.
sourceLieGroups.inv_left_compose — Functioninv_left_compose(G::LieGroup, g, h)
-inv_left_compose!(G::LieGroup, k, g, h)
Compute the inverse of the left group multiplication $λ_g(h) = g∘h$, on the LieGroup G, that is, compute $λ_g^{-1}(h) = g^{-1}∘h$. This can be done in-place of k.
sourceLieGroups.inv_left_compose! — Functioncompose(G::LieGroup, g, h)
-compose!(G::LieGroup, k, g, h)
Perform the group oepration $g ∘ h$ for two $g, h ∈ \mathcal G$ on the LieGroup G. This can also be done in-place of h.
sourceLieGroups.inv_right_compose — Functioninv_right_compose(G::LieGroup, h, g)
-inv_right_compose!(G::LieGroup, k, h, g)
Compute the inverse of the right group multiplication $ρ_g(h) = h∘g$, on the LieGroup G, that is Compute $ρ_g^{-1}(h) = h∘g^{-1}$. This can be done in-place of k.
sourceLieGroups.inv_right_compose! — Functioninv_right_compose(G::LieGroup, h, g)
-inv_right_compose!(G::LieGroup, k, h, g)
Compute the inverse of the right group multiplication $ρ_g(h) = h∘g$, on the LieGroup G, that is Compute $ρ_g^{-1}(h) = h∘g^{-1}$. This can be done in-place of k.
sourceLieGroups.conjugate — Functionconjugate(G::LieGroup, g, h)
-conjugate!(G::LieGroup, k, g, h)
Compute the conjugation map $c_g: \mathcal G → \mathcal G$ given by $c_g(h) = g∘h∘g^{-1}$. This can be done in-place of k.
sourceLieGroups.conjugate! — Functionconjugate(G::LieGroup, g, h)
-conjugate!(G::LieGroup, k, g, h)
Compute the conjugation map $c_g: \mathcal G → \mathcal G$ given by $c_g(h) = g∘h∘g^{-1}$. This can be done in-place of k.
sourceLieGroups.diff_conjugate — Functiondiff_conjugate(G::LieGroup, g, h, X)
-diff_conjugate!(G::LieGroup, Y, g, h, X)
Compute the differential of the conjugate $c_g(h) = g∘h∘g^{-1}$, which can be performed in-place of Y.
\[ D(c_g(h))[X], \qquad X ∈ \mathfrak g.\]
sourceLieGroups.diff_conjugate! — Functiondiff_conjugate(G::LieGroup, g, h, X)
-diff_conjugate!(G::LieGroup, Y, g, h, X)
Compute the differential of the conjugate $c_g(h) = g∘h∘g^{-1}$, which can be performed in-place of Y.
\[ D(c_g(h))[X], \qquad X ∈ \mathfrak g.\]
sourceBase.exp — Functionexp(G::LieGroup, g, X, t::Number=1)
-exp!(G::LieGroup, h, g, X, t::Number=1)
Compute the Lie group exponential map given by
\[\exp_g X = g∘\exp_{\mathcal G}(X)\]
where X can be scaled by t, the computation can be performed in-place of h, and $\exp_{\mathcal G}$ denotes the Lie group exponential function.
Note If g is the Identity the Lie group exponential function is computed directly. Implementing the Lie group exponential function introduces a default implementation for this function.
Note The Lie group exponential map is usually different from the exponential map with respect to the metric of the underlying Riemannian manifold $\mathcal M$. To access the (Riemannian) exponential map, use exp(base_manifoldG, g, X).
sourceexp(G::LieGroup, e::Identity, X)
-exp!(G::LieGroup, h, e::Identity, X)
Compute the (Lie group) exponential function
\[\exp_{\mathcal G}: \mathfrak g → \mathcal G,\qquad \exp_{\mathcal G}(X) = γ_X(1),\]
where $γ_X$ is the unique solution of the initial value problem
\[γ(0) = \mathrm e, \quad γ'(t) = γ(t)⋅X.\]
The computation can be performed in-place of h.
See also [HN12, Definition 9.2.2].
sourceManifoldsBase.exp! — Functionexp(G::LieGroup, g, X, t::Number=1)
-exp!(G::LieGroup, h, g, X, t::Number=1)
Compute the Lie group exponential map given by
\[\exp_g X = g∘\exp_{\mathcal G}(X)\]
where X can be scaled by t, the computation can be performed in-place of h, and $\exp_{\mathcal G}$ denotes the Lie group exponential function.
Note If g is the Identity the Lie group exponential function is computed directly. Implementing the Lie group exponential function introduces a default implementation for this function.
Note The Lie group exponential map is usually different from the exponential map with respect to the metric of the underlying Riemannian manifold $\mathcal M$. To access the (Riemannian) exponential map, use exp(base_manifoldG, g, X).
sourceexp(G::LieGroup, e::Identity, X)
-exp!(G::LieGroup, h, e::Identity, X)
Compute the (Lie group) exponential function
\[\exp_{\mathcal G}: \mathfrak g → \mathcal G,\qquad \exp_{\mathcal G}(X) = γ_X(1),\]
where $γ_X$ is the unique solution of the initial value problem
\[γ(0) = \mathrm e, \quad γ'(t) = γ(t)⋅X.\]
The computation can be performed in-place of h.
See also [HN12, Definition 9.2.2].
sourceLieGroups.identity_element — Functionidentity_element(G::LieGroup)
-identity_element!(G::LieGroup, g)
Return a point representation of the Identity on the LieGroup G. By default this representation is the default array or number representation. It should return the corresponding default representation of $e$ as a point on G if points are not represented by arrays. This can be performed in-place of g.
sourceLieGroups.identity_element! — Functionidentity_element(G::LieGroup)
-identity_element!(G::LieGroup, g)
Return a point representation of the Identity on the LieGroup G. By default this representation is the default array or number representation. It should return the corresponding default representation of $e$ as a point on G if points are not represented by arrays. This can be performed in-place of g.
sourceLieGroups.is_identity — Functionis_identity(G::LieGroup, q; kwargs)
Check whether q is the identity on the LieGroup $\mathcal G$. This means it is either the Identity{O} with the respect to the corresponding AbstractGroupOperation O, or (approximately) the correct point representation.
See also
sourceBase.inv — Methodinv(G::LieGroup, g)
-inv!(G::LieGroup, h, g)
Compute the inverse group element $g^{-1}$ with respect to the AbstractGroupOperation $∘$ on the LieGroup $\mathcal G$, that is, return the unique element $h=g^{-1}$ such that $h∘g=\mathrm e$, where $\mathrm e$ denotes the Identity.
This can be done in-place of h, without side effects, that is you can do inv!(G, g, g).
sourceLieGroups.inv! — Functioninv(G::LieGroup, g)
-inv!(G::LieGroup, h, g)
Compute the inverse group element $g^{-1}$ with respect to the AbstractGroupOperation $∘$ on the LieGroup $\mathcal G$, that is, return the unique element $h=g^{-1}$ such that $h∘g=\mathrm e$, where $\mathrm e$ denotes the Identity.
This can be done in-place of h, without side effects, that is you can do inv!(G, g, g).
sourceLieGroups.diff_inv — Functiondiff_inv(G::LieGroup, g, X)
-diff_inv!(G::LieGroup, Y, g, X)
Compute the differential of the function $ι_{\mathcal G}(p) = p^-1$, where `Dι_{\mathcal G}(p): \mathfrak g → \mathfrak g. This can be done in-place ofY`.
sourceLieGroups.diff_inv! — Functiondiff_inv(G::LieGroup, g, X)
-diff_inv!(G::LieGroup, Y, g, X)
Compute the differential of the function $ι_{\mathcal G}(p) = p^-1$, where `Dι_{\mathcal G}(p): \mathfrak g → \mathfrak g. This can be done in-place ofY`.
sourceBase.log — Functionlog(G::LieGroup, g, h)
-log!(G::LieGroup, X, g, h)
Compute the Lie group logarithmic map
\[\log_g h = ∘\log_{\mathcal G}(g^{-1}∘h)\]
where $\log_{\mathcal G}$ denotes the Lie group logarithmic function The computation can be performed in-place of X.
Note If g is the Identity the Lie group logarithmic function is computed directly. Implementing the Lie group logarithmic function introduces a default implementation for this function.
Note The Lie group logarithmic map is usually different from the logarithmic map with respect to the metric of the underlying Riemannian manifold $\mathcal M$. To access the (Riemannian) logarithmic map, use log(base_manifoldG, g, h).
sourcelog(G::LieGroup, e::Identity, g)
-log!(G::LieGroup, X, e::Identity, g)
Compute the (Lie group) logarithmic function $\log_{\mathcal G}: \mathcal G → \mathfrak g$, which is the inverse of the Lie group exponential function The compuation can be performed in-place of X.
sourceManifoldsBase.log! — Functionlog(G::LieGroup, g, h)
-log!(G::LieGroup, X, g, h)
Compute the Lie group logarithmic map
\[\log_g h = ∘\log_{\mathcal G}(g^{-1}∘h)\]
where $\log_{\mathcal G}$ denotes the Lie group logarithmic function The computation can be performed in-place of X.
Note If g is the Identity the Lie group logarithmic function is computed directly. Implementing the Lie group logarithmic function introduces a default implementation for this function.
Note The Lie group logarithmic map is usually different from the logarithmic map with respect to the metric of the underlying Riemannian manifold $\mathcal M$. To access the (Riemannian) logarithmic map, use log(base_manifoldG, g, h).
sourcelog(G::LieGroup, e::Identity, g)
-log!(G::LieGroup, X, e::Identity, g)
Compute the (Lie group) logarithmic function $\log_{\mathcal G}: \mathcal G → \mathfrak g$, which is the inverse of the Lie group exponential function The compuation can be performed in-place of X.
sourceActions on Lie groups
LieGroups.AbstractGroupAction — TypeAbstractGroupAction{T<:AbstractGroupActionType, L<:LieGroup, M<:AbstractManifold}
An abstract group action of AbstractGroupActionType T of a LieGroup of type L acting on an AbstractManifold of type M.
See [HN12, Section 9.1.3] for more details.
sourceLieGroups.AbstractGroupActionType — TypeAbstractGroupActionType
An abstract supertype for group actions.
sourceLieGroups.AbstractLeftGroupActionType — TypeAbstractLeftGroupActionType <: AbstractGroupActionType
A type representing a (smooth) group action $σ: \mathcal G × \mathcal M → \mathcal M$ of a LieGroup $\mathcal G$ acting (from the left) on an AbstractManifold $\mathcal M$. with the following properties
- $σ(\mathrm e, p) = p$ holds for all $p ∈ \mathcal M$
- $σ(g, σ(h, p)) = σ(g∘h, p)$ holds for all $g,h ∈ \mathcal G$, $p ∈ \mathcal M$
where $∘$ denotes the group operation of the LieGroup $\mathcal G$. See also [HN12, Definition 9.1.11].
The type of action can be seen a bit better when writing the action as a family $σ_g(p)$: we obtain from the second property as
\[ σ_g(σ_h(p)) = σ_{gh}(p)\]
and see that $g$ appears on the left.
To emphasize the side the group operation is acting from, we sometimes write $σ^{\mathrm L}$. If the action is clear from context we write $σ(g, p) = g ⋅ p$.
One notable example of a left action is the inverse of an action of AbstractRightGroupActionType $σ^{\mathrm R}$, which is given by $τ_g = (σ^{\mathrm R}_g)^{-1} = σ^{\mathrm R}_{g^{-1}}$. We obtain
\[τ_g(τ_h(p))
+Identity(::Type{AbstractGroupOperation})
create the identity of the corresponding subtype O<:AbstractGroupOperation
sourceFunctions on Lie Groups
Base.adjoint — Functionadjoint(G::LieGroup, g X)
+adjoint!(G::LieGroup, Y, g, X)
Compute the adjoint $\mathrm{Ad}(g): \mathfrak g → \mathfrak g$, which is defined as the differential diff_conjugate of the conjugate $c_g(h) = g∘h∘g^{-1}$ evaluated at the Identity $h=\mathrm e$. The operation can be performed in-place of Y.
\[ \mathrm{Ad}(g)[X] = D c_g(\mathrm e) [X], \qquad X ∈ \mathfrak g.\]
see [HN12, Section 9.2.3].
On matrix Lie groups the adjoint reads $\mathrm{Ad}(g)[X] = g∘X∘g^{-1}$.
sourceLieGroups.adjoint! — Functionadjoint(G::LieGroup, g X)
+adjoint!(G::LieGroup, Y, g, X)
Compute the adjoint $\mathrm{Ad}(g): \mathfrak g → \mathfrak g$, which is defined as the differential diff_conjugate of the conjugate $c_g(h) = g∘h∘g^{-1}$ evaluated at the Identity $h=\mathrm e$. The operation can be performed in-place of Y.
\[ \mathrm{Ad}(g)[X] = D c_g(\mathrm e) [X], \qquad X ∈ \mathfrak g.\]
see [HN12, Section 9.2.3].
On matrix Lie groups the adjoint reads $\mathrm{Ad}(g)[X] = g∘X∘g^{-1}$.
sourceManifoldsBase.base_manifold — Functionbase_manifold(G::LieGroup)
Return the manifold stored within the LieGroup G.
sourcebase_manifold(A::AbstractGroupAction)
Return the AbstractManifold of the AbstractGroupAction.
sourceLieGroups.compose — Functioncompose(G::LieGroup, g, h)
+compose!(G::LieGroup, k, g, h)
Perform the group oepration $g ∘ h$ for two $g, h ∈ \mathcal G$ on the LieGroup G. This can also be done in-place of h.
sourceLieGroups.compose! — Functioncompose(G::LieGroup, g, h)
+compose!(G::LieGroup, k, g, h)
Perform the group oepration $g ∘ h$ for two $g, h ∈ \mathcal G$ on the LieGroup G. This can also be done in-place of h.
sourceLieGroups.diff_left_compose — Functiondiff_left_compose(G::LieGroup, g, h, X)
+diff_left_compose!(G::LieGroup, Y, g, h, X)
Compute the differential of the left group multiplication $λ_g(h) = g∘h$, on the LieGroup G, that is Compute $Dλ_g(h)[X]$, $X ∈ 𝔤$. This can be done in-place of Y.
sourceLieGroups.diff_left_compose! — Functiondiff_left_compose(G::LieGroup, g, h, X)
+diff_left_compose!(G::LieGroup, Y, g, h, X)
Compute the differential of the left group multiplication $λ_g(h) = g∘h$, on the LieGroup G, that is Compute $Dλ_g(h)[X]$, $X ∈ 𝔤$. This can be done in-place of Y.
sourceLieGroups.diff_right_compose — Functiondiff_right_compose(G::LieGroup, h, g, X)
+diff_right_compose!(G::LieGroup, Y, h, g, X)
Compute the differential of the right group multiplication $ρ_g(h) = h∘g$, on the LieGroup G, that is Compute $Dρ_g(h)[X]$, $X ∈ 𝔤$ This can be done in-place of Y.
sourceLieGroups.diff_right_compose! — Functiondiff_right_compose(G::LieGroup, h, g, X)
+diff_right_compose!(G::LieGroup, Y, h, g, X)
Compute the differential of the right group multiplication $ρ_g(h) = h∘g$, on the LieGroup G, that is Compute $Dρ_g(h)[X]$, $X ∈ 𝔤$ This can be done in-place of Y.
sourceLieGroups.inv_left_compose — Functioninv_left_compose(G::LieGroup, g, h)
+inv_left_compose!(G::LieGroup, k, g, h)
Compute the inverse of the left group multiplication $λ_g(h) = g∘h$, on the LieGroup G, that is, compute $λ_g^{-1}(h) = g^{-1}∘h$. This can be done in-place of k.
sourceLieGroups.inv_left_compose! — Functioncompose(G::LieGroup, g, h)
+compose!(G::LieGroup, k, g, h)
Perform the group oepration $g ∘ h$ for two $g, h ∈ \mathcal G$ on the LieGroup G. This can also be done in-place of h.
sourceLieGroups.inv_right_compose — Functioninv_right_compose(G::LieGroup, h, g)
+inv_right_compose!(G::LieGroup, k, h, g)
Compute the inverse of the right group multiplication $ρ_g(h) = h∘g$, on the LieGroup G, that is Compute $ρ_g^{-1}(h) = h∘g^{-1}$. This can be done in-place of k.
sourceLieGroups.inv_right_compose! — Functioninv_right_compose(G::LieGroup, h, g)
+inv_right_compose!(G::LieGroup, k, h, g)
Compute the inverse of the right group multiplication $ρ_g(h) = h∘g$, on the LieGroup G, that is Compute $ρ_g^{-1}(h) = h∘g^{-1}$. This can be done in-place of k.
sourceLieGroups.conjugate — Functionconjugate(G::LieGroup, g, h)
+conjugate!(G::LieGroup, k, g, h)
Compute the conjugation map $c_g: \mathcal G → \mathcal G$ given by $c_g(h) = g∘h∘g^{-1}$. This can be done in-place of k.
sourceLieGroups.conjugate! — Functionconjugate(G::LieGroup, g, h)
+conjugate!(G::LieGroup, k, g, h)
Compute the conjugation map $c_g: \mathcal G → \mathcal G$ given by $c_g(h) = g∘h∘g^{-1}$. This can be done in-place of k.
sourceLieGroups.diff_conjugate — Functiondiff_conjugate(G::LieGroup, g, h, X)
+diff_conjugate!(G::LieGroup, Y, g, h, X)
Compute the differential of the conjugate $c_g(h) = g∘h∘g^{-1}$, which can be performed in-place of Y.
\[ D(c_g(h))[X], \qquad X ∈ \mathfrak g.\]
sourceLieGroups.diff_conjugate! — Functiondiff_conjugate(G::LieGroup, g, h, X)
+diff_conjugate!(G::LieGroup, Y, g, h, X)
Compute the differential of the conjugate $c_g(h) = g∘h∘g^{-1}$, which can be performed in-place of Y.
\[ D(c_g(h))[X], \qquad X ∈ \mathfrak g.\]
sourceBase.exp — Functionexp(G::LieGroup, g, X, t::Number=1)
+exp!(G::LieGroup, h, g, X, t::Number=1)
Compute the Lie group exponential map given by
\[\exp_g X = g∘\exp_{\mathcal G}(X)\]
where X can be scaled by t, the computation can be performed in-place of h, and $\exp_{\mathcal G}$ denotes the Lie group exponential function.
Note If g is the Identity the Lie group exponential function is computed directly. Implementing the Lie group exponential function introduces a default implementation for this function.
Note The Lie group exponential map is usually different from the exponential map with respect to the metric of the underlying Riemannian manifold $\mathcal M$. To access the (Riemannian) exponential map, use exp(base_manifoldG, g, X).
sourceexp(G::LieGroup, e::Identity, X)
+exp!(G::LieGroup, h, e::Identity, X)
Compute the (Lie group) exponential function
\[\exp_{\mathcal G}: \mathfrak g → \mathcal G,\qquad \exp_{\mathcal G}(X) = γ_X(1),\]
where $γ_X$ is the unique solution of the initial value problem
\[γ(0) = \mathrm e, \quad γ'(t) = γ(t)⋅X.\]
The computation can be performed in-place of h.
See also [HN12, Definition 9.2.2].
sourceManifoldsBase.exp! — Functionexp(G::LieGroup, g, X, t::Number=1)
+exp!(G::LieGroup, h, g, X, t::Number=1)
Compute the Lie group exponential map given by
\[\exp_g X = g∘\exp_{\mathcal G}(X)\]
where X can be scaled by t, the computation can be performed in-place of h, and $\exp_{\mathcal G}$ denotes the Lie group exponential function.
Note If g is the Identity the Lie group exponential function is computed directly. Implementing the Lie group exponential function introduces a default implementation for this function.
Note The Lie group exponential map is usually different from the exponential map with respect to the metric of the underlying Riemannian manifold $\mathcal M$. To access the (Riemannian) exponential map, use exp(base_manifoldG, g, X).
sourceexp(G::LieGroup, e::Identity, X)
+exp!(G::LieGroup, h, e::Identity, X)
Compute the (Lie group) exponential function
\[\exp_{\mathcal G}: \mathfrak g → \mathcal G,\qquad \exp_{\mathcal G}(X) = γ_X(1),\]
where $γ_X$ is the unique solution of the initial value problem
\[γ(0) = \mathrm e, \quad γ'(t) = γ(t)⋅X.\]
The computation can be performed in-place of h.
See also [HN12, Definition 9.2.2].
sourceLieGroups.identity_element — Functionidentity_element(G::LieGroup)
+identity_element!(G::LieGroup, g)
Return a point representation of the Identity on the LieGroup G. By default this representation is the default array or number representation. It should return the corresponding default representation of $e$ as a point on G if points are not represented by arrays. This can be performed in-place of g.
sourceLieGroups.identity_element! — Functionidentity_element(G::LieGroup)
+identity_element!(G::LieGroup, g)
Return a point representation of the Identity on the LieGroup G. By default this representation is the default array or number representation. It should return the corresponding default representation of $e$ as a point on G if points are not represented by arrays. This can be performed in-place of g.
sourceLieGroups.is_identity — Functionis_identity(G::LieGroup, q; kwargs)
Check whether q is the identity on the LieGroup $\mathcal G$. This means it is either the Identity{O} with the respect to the corresponding AbstractGroupOperation O, or (approximately) the correct point representation.
See also
sourceBase.inv — Methodinv(G::LieGroup, g)
+inv!(G::LieGroup, h, g)
Compute the inverse group element $g^{-1}$ with respect to the AbstractGroupOperation $∘$ on the LieGroup $\mathcal G$, that is, return the unique element $h=g^{-1}$ such that $h∘g=\mathrm e$, where $\mathrm e$ denotes the Identity.
This can be done in-place of h, without side effects, that is you can do inv!(G, g, g).
sourceLieGroups.inv! — Functioninv(G::LieGroup, g)
+inv!(G::LieGroup, h, g)
Compute the inverse group element $g^{-1}$ with respect to the AbstractGroupOperation $∘$ on the LieGroup $\mathcal G$, that is, return the unique element $h=g^{-1}$ such that $h∘g=\mathrm e$, where $\mathrm e$ denotes the Identity.
This can be done in-place of h, without side effects, that is you can do inv!(G, g, g).
sourceLieGroups.diff_inv — Functiondiff_inv(G::LieGroup, g, X)
+diff_inv!(G::LieGroup, Y, g, X)
Compute the differential of the function $ι_{\mathcal G}(p) = p^-1$, where `Dι_{\mathcal G}(p): \mathfrak g → \mathfrak g. This can be done in-place ofY`.
sourceLieGroups.diff_inv! — Functiondiff_inv(G::LieGroup, g, X)
+diff_inv!(G::LieGroup, Y, g, X)
Compute the differential of the function $ι_{\mathcal G}(p) = p^-1$, where `Dι_{\mathcal G}(p): \mathfrak g → \mathfrak g. This can be done in-place ofY`.
sourceBase.log — Functionlog(G::LieGroup, g, h)
+log!(G::LieGroup, X, g, h)
Compute the Lie group logarithmic map
\[\log_g h = ∘\log_{\mathcal G}(g^{-1}∘h)\]
where $\log_{\mathcal G}$ denotes the Lie group logarithmic function The computation can be performed in-place of X.
Note If g is the Identity the Lie group logarithmic function is computed directly. Implementing the Lie group logarithmic function introduces a default implementation for this function.
Note The Lie group logarithmic map is usually different from the logarithmic map with respect to the metric of the underlying Riemannian manifold $\mathcal M$. To access the (Riemannian) logarithmic map, use log(base_manifoldG, g, h).
sourcelog(G::LieGroup, e::Identity, g)
+log!(G::LieGroup, X, e::Identity, g)
Compute the (Lie group) logarithmic function $\log_{\mathcal G}: \mathcal G → \mathfrak g$, which is the inverse of the Lie group exponential function The compuation can be performed in-place of X.
sourceManifoldsBase.log! — Functionlog(G::LieGroup, g, h)
+log!(G::LieGroup, X, g, h)
Compute the Lie group logarithmic map
\[\log_g h = ∘\log_{\mathcal G}(g^{-1}∘h)\]
where $\log_{\mathcal G}$ denotes the Lie group logarithmic function The computation can be performed in-place of X.
Note If g is the Identity the Lie group logarithmic function is computed directly. Implementing the Lie group logarithmic function introduces a default implementation for this function.
Note The Lie group logarithmic map is usually different from the logarithmic map with respect to the metric of the underlying Riemannian manifold $\mathcal M$. To access the (Riemannian) logarithmic map, use log(base_manifoldG, g, h).
sourcelog(G::LieGroup, e::Identity, g)
+log!(G::LieGroup, X, e::Identity, g)
Compute the (Lie group) logarithmic function $\log_{\mathcal G}: \mathcal G → \mathfrak g$, which is the inverse of the Lie group exponential function The compuation can be performed in-place of X.
sourceActions on Lie groups
LieGroups.AbstractGroupAction — TypeAbstractGroupAction{T<:AbstractGroupActionType, L<:LieGroup, M<:AbstractManifold}
An abstract group action of AbstractGroupActionType T of a LieGroup of type L acting on an AbstractManifold of type M.
See [HN12, Section 9.1.3] for more details.
sourceLieGroups.AbstractGroupActionType — TypeAbstractGroupActionType
An abstract supertype for group actions.
sourceLieGroups.AbstractLeftGroupActionType — TypeAbstractLeftGroupActionType <: AbstractGroupActionType
A type representing a (smooth) group action $σ: \mathcal G × \mathcal M → \mathcal M$ of a LieGroup $\mathcal G$ acting (from the left) on an AbstractManifold $\mathcal M$. with the following properties
- $σ(\mathrm e, p) = p$ holds for all $p ∈ \mathcal M$
- $σ(g, σ(h, p)) = σ(g∘h, p)$ holds for all $g,h ∈ \mathcal G$, $p ∈ \mathcal M$
where $∘$ denotes the group operation of the LieGroup $\mathcal G$. See also [HN12, Definition 9.1.11].
The type of action can be seen a bit better when writing the action as a family $σ_g(p)$: we obtain from the second property as
\[ σ_g(σ_h(p)) = σ_{gh}(p)\]
and see that $g$ appears on the left.
To emphasize the side the group operation is acting from, we sometimes write $σ^{\mathrm L}$. If the action is clear from context we write $σ(g, p) = g ⋅ p$.
One notable example of a left action is the inverse of an action of AbstractRightGroupActionType $σ^{\mathrm R}$, which is given by $τ_g = (σ^{\mathrm R}_g)^{-1} = σ^{\mathrm R}_{g^{-1}}$. We obtain
\[τ_g(τ_h(p))
= σ^{\mathrm R}_{g^{-1}}(σ^{\mathrm R}_{h^{-1}}(p))
= σ^{\mathrm R}_{h^{-1}g^{-1}}(p)
= σ^{\mathrm R}_{(gh)^{-1}}(p)
-τ_{gh}(p).\]
Note In function definitions we follow the idea of the family of actions and use the order (M, g, p) in function signatures.
sourceLieGroups.AbstractRightGroupActionType — TypeAbstractRightGroupActionType <: AbstractGroupActionType
A type representing a (smooth) group action $σ: \mathcal M × \mathcal G → \mathcal M$ of a LieGroup $\mathcal G$ acting (from the right) on an AbstractManifold $\mathcal M$. with the following properties
- $σ(p, \mathrm e) = p$ holds for all $p ∈ \mathcal M$
- $σ(σ(p, g), h) = σ(p, g∘h)$ holds for all $g,h ∈ \mathcal G$, $p ∈ \mathcal M$
where $∘$ denotes the group operation of the LieGroup $\mathcal G$. See also [HN12, Remark 9.1.12].
The type of action can be seen a bit better when writing the action as a family $σ_g(p)$: we obtain from the second property as
\[ σ_g(σ_h(p)) = σ_{hg}(p)\]
and see that $g$ appears on the right.
To emphasize the side the group operation is acting from, we sometimes write $σ^{\mathrm R}$. If the action is clear from context we write $σ(p, g) = p ⋅ g$.
One notable example of a right action is the inverse of an action of AbstractLeftGroupActionType $σ^{\mathrm L}$, which is given by $τ_g = (σ^{\mathrm L}_g)^{-1} = σ^{\mathrm L}_{g^{-1}}$. We obtain
\[τ_g(τ_h(p))
+τ_{gh}(p).\]
Note In function definitions we follow the idea of the family of actions and use the order (M, g, p) in function signatures.
sourceLieGroups.AbstractRightGroupActionType — TypeAbstractRightGroupActionType <: AbstractGroupActionType
A type representing a (smooth) group action $σ: \mathcal M × \mathcal G → \mathcal M$ of a LieGroup $\mathcal G$ acting (from the right) on an AbstractManifold $\mathcal M$. with the following properties
- $σ(p, \mathrm e) = p$ holds for all $p ∈ \mathcal M$
- $σ(σ(p, g), h) = σ(p, g∘h)$ holds for all $g,h ∈ \mathcal G$, $p ∈ \mathcal M$
where $∘$ denotes the group operation of the LieGroup $\mathcal G$. See also [HN12, Remark 9.1.12].
The type of action can be seen a bit better when writing the action as a family $σ_g(p)$: we obtain from the second property as
\[ σ_g(σ_h(p)) = σ_{hg}(p)\]
and see that $g$ appears on the right.
To emphasize the side the group operation is acting from, we sometimes write $σ^{\mathrm R}$. If the action is clear from context we write $σ(p, g) = p ⋅ g$.
One notable example of a right action is the inverse of an action of AbstractLeftGroupActionType $σ^{\mathrm L}$, which is given by $τ_g = (σ^{\mathrm L}_g)^{-1} = σ^{\mathrm L}_{g^{-1}}$. We obtain
\[τ_g(τ_h(p))
= σ^{\mathrm L}_{g^{-1}}(σ^{\mathrm L}_{h^{-1}}(p))
= σ^{\mathrm L}_{g^{-1}h^{-1}}(p)
= σ^{\mathrm L}_{(hg)^{-1}}(p)
-τ_{hg}(p).\]
Note In function definitions we follow the idea of the family of actions and use the order (M, g, p) in function signatures.
sourceFunctions for Lie group actions
Base.inv — Method inv(T::AbstractGroupActionType)
Return the type representing the inverse of an AbstractGroupActionType.
sourceBase.inv — Method inv(A::AbstractGroupAction{T})
Return the tuple representing the inverse of an AbstractGroupAction of AbstractGroupActionType T. This is usually done by returning the group action with the inverse type of T.
sourceLieGroups.base_lie_group — Methodbase_Lie_group(A::AbstractGroupAction)
Return the LieGroup of the AbstractGroupAction.
sourceLieGroups.diff_apply! — Methoddiff_apply(A::AbstractGroupAction{T, L, M}, g, p, X)
-diff_apply!(A::AbstractGroupAction{T, L, M}, Y, g, p, X)
Compute the differential $D_p σ_g(p): T_p\mathcal M → T_{σ_g(p)}\mathcal M$, where for a left group action we have $σ_g(p) = σ(g,p)$, for a right action $σ_g(p) = σ(p, g)$.
sourceLieGroups.diff_apply — Methoddiff_apply(A::AbstractGroupAction{T, L, M}, g, p, X)
-diff_apply!(A::AbstractGroupAction{T, L, M}, Y, g, p, X)
Compute the differential $D_p σ_g(p): T_p\mathcal M → T_{σ_g(p)}\mathcal M$, where for a left group action we have $σ_g(p) = σ(g,p)$, for a right action $σ_g(p) = σ(p, g)$.
sourceLieGroups.diff_group_apply! — Methoddiff_group_apply(A::AbstractGroupAction{T, L, M}, g, p, X)
-diff_group_apply!(A::AbstractGroupAction{T, L, M}, Y, g, p, X)
Compute the differential $D_g σ_p(g): T_g\mathcal G → T_{σ_p(g)}\mathcal M$, where we use the short hand notation $σ_p(g) = σ(g,p)$ for a left action, and for a right action $σ_p(g) = σ(p, g)$.
sourceLieGroups.diff_group_apply — Methoddiff_group_apply(A::AbstractGroupAction{T, L, M}, g, p, X)
-diff_group_apply!(A::AbstractGroupAction{T, L, M}, Y, g, p, X)
Compute the differential $D_g σ_p(g): T_g\mathcal G → T_{σ_p(g)}\mathcal M$, where we use the short hand notation $σ_p(g) = σ(g,p)$ for a left action, and for a right action $σ_p(g) = σ(p, g)$.
sourceLieGroups.switch — Methodswitch(T::AbstractGroupActionType)
Return the object representing an AbstractGroupActionType related to a group operation action that switched the side, that is it turns a left action type into its corresponding right action type.
sourceLieGroups.switch — Method switch(A::AbstractGroupAction{T})
Return the group operation action representing the similar AbstractGroupAction of AbstractGroupActionType T but acting from the other side. It switches left to right and vice versa. This is done by returning the group action with the “switched” type of T.
sourceManifolds.apply! — Methodapply(A::AbstractGroupAction{T, L, M}, g, p)
-apply!(A::AbstractGroupAction{T, L, M}, q, g, p)
Apply the group action induced by $g ∈ \mathcal G$ to $p ∈ \mathcal M$, where the kind of group action is indicated by the AbstractGroupActionType T. This can be perfomed in-place of q.
sourceManifolds.apply — Methodapply(A::AbstractGroupAction{T, L, M}, g, p)
-apply!(A::AbstractGroupAction{T, L, M}, q, g, p)
Apply the group action induced by $g ∈ \mathcal G$ to $p ∈ \mathcal M$, where the kind of group action is indicated by the AbstractGroupActionType T. This can be perfomed in-place of q.
sourceManifoldsBase.base_manifold — Methodbase_manifold(A::AbstractGroupAction)
Return the AbstractManifold of the AbstractGroupAction.
sourceSpecific Lie group actions
LieGroups.GroupOperationAction — TypeGroupOperationAction{T<:AbstractLeftGroupActionType,G<:LieGroup} <: AbstractGroupAction{T,G,G}
The AbstractGroupAction.
sourceLieGroups.InverseLeftGroupOperation — TypeInverseLeftGroupOperation <: AbstractRightGroupActionType
A type for the AbstractLeftGroupActionType when acting on the group itself given by the inverse of a LeftGroupOperation $σ_h$ as
\[τ_h(g) \coloneqq σ_h^{-1}(g) = σ(h^{-1},g) = h^{-1}∘g\]
Note that while in naming it is the inverse of the left action, it's properties yield that is is an AbstractRightGroupActionType, since
\[τ_g(τ_h(p))
+τ_{hg}(p).\]
Note In function definitions we follow the idea of the family of actions and use the order (M, g, p) in function signatures.
sourceFunctions for Lie group actions
Base.inv — Method inv(T::AbstractGroupActionType)
Return the type representing the inverse of an AbstractGroupActionType.
sourceBase.inv — Method inv(A::AbstractGroupAction{T})
Return the tuple representing the inverse of an AbstractGroupAction of AbstractGroupActionType T. This is usually done by returning the group action with the inverse type of T.
sourceLieGroups.base_lie_group — Methodbase_Lie_group(A::AbstractGroupAction)
Return the LieGroup of the AbstractGroupAction.
sourceLieGroups.diff_apply! — Methoddiff_apply(A::AbstractGroupAction{T, L, M}, g, p, X)
+diff_apply!(A::AbstractGroupAction{T, L, M}, Y, g, p, X)
Compute the differential $D_p σ_g(p): T_p\mathcal M → T_{σ_g(p)}\mathcal M$, where for a left group action we have $σ_g(p) = σ(g,p)$, for a right action $σ_g(p) = σ(p, g)$.
sourceLieGroups.diff_apply — Methoddiff_apply(A::AbstractGroupAction{T, L, M}, g, p, X)
+diff_apply!(A::AbstractGroupAction{T, L, M}, Y, g, p, X)
Compute the differential $D_p σ_g(p): T_p\mathcal M → T_{σ_g(p)}\mathcal M$, where for a left group action we have $σ_g(p) = σ(g,p)$, for a right action $σ_g(p) = σ(p, g)$.
sourceLieGroups.diff_group_apply! — Methoddiff_group_apply(A::AbstractGroupAction{T, L, M}, g, p, X)
+diff_group_apply!(A::AbstractGroupAction{T, L, M}, Y, g, p, X)
Compute the differential $D_g σ_p(g): T_g\mathcal G → T_{σ_p(g)}\mathcal M$, where we use the short hand notation $σ_p(g) = σ(g,p)$ for a left action, and for a right action $σ_p(g) = σ(p, g)$.
sourceLieGroups.diff_group_apply — Methoddiff_group_apply(A::AbstractGroupAction{T, L, M}, g, p, X)
+diff_group_apply!(A::AbstractGroupAction{T, L, M}, Y, g, p, X)
Compute the differential $D_g σ_p(g): T_g\mathcal G → T_{σ_p(g)}\mathcal M$, where we use the short hand notation $σ_p(g) = σ(g,p)$ for a left action, and for a right action $σ_p(g) = σ(p, g)$.
sourceLieGroups.switch — Methodswitch(T::AbstractGroupActionType)
Return the object representing an AbstractGroupActionType related to a group operation action that switched the side, that is it turns a left action type into its corresponding right action type.
sourceLieGroups.switch — Method switch(A::AbstractGroupAction{T})
Return the group operation action representing the similar AbstractGroupAction of AbstractGroupActionType T but acting from the other side. It switches left to right and vice versa. This is done by returning the group action with the “switched” type of T.
sourceManifolds.apply! — Methodapply(A::AbstractGroupAction{T, L, M}, g, p)
+apply!(A::AbstractGroupAction{T, L, M}, q, g, p)
Apply the group action induced by $g ∈ \mathcal G$ to $p ∈ \mathcal M$, where the kind of group action is indicated by the AbstractGroupActionType T. This can be perfomed in-place of q.
sourceManifolds.apply — Methodapply(A::AbstractGroupAction{T, L, M}, g, p)
+apply!(A::AbstractGroupAction{T, L, M}, q, g, p)
Apply the group action induced by $g ∈ \mathcal G$ to $p ∈ \mathcal M$, where the kind of group action is indicated by the AbstractGroupActionType T. This can be perfomed in-place of q.
sourceManifoldsBase.base_manifold — Methodbase_manifold(A::AbstractGroupAction)
Return the AbstractManifold of the AbstractGroupAction.
sourceSpecific Lie group actions
LieGroups.GroupOperationAction — TypeGroupOperationAction{T<:AbstractLeftGroupActionType,G<:LieGroup} <: AbstractGroupAction{T,G,G}
The AbstractGroupAction.
sourceLieGroups.InverseLeftGroupOperation — TypeInverseLeftGroupOperation <: AbstractRightGroupActionType
A type for the AbstractLeftGroupActionType when acting on the group itself given by the inverse of a LeftGroupOperation $σ_h$ as
\[τ_h(g) \coloneqq σ_h^{-1}(g) = σ(h^{-1},g) = h^{-1}∘g\]
Note that while in naming it is the inverse of the left action, it's properties yield that is is an AbstractRightGroupActionType, since
\[τ_g(τ_h(p))
= σ^{\mathrm L}_{g^{-1}}(σ^{\mathrm L}_{h^{-1}}(p))
= σ^{\mathrm L}_{g^{-1}h^{-1}}(p)
= σ^{\mathrm L}_{(hg)^{-1}}(p)
-τ_{hg}(p).\]
for its inverse $(σ_h)^{-1}$ see InverseLeftGroupOperation.
Note Some literature also calls this by itself the right group operation action.
sourceLieGroups.InverseRightGroupOperation — TypeInverseRightGroupOperation <: AbstractLeftGroupActionType
A type for the AbstractLeftGroupActionType when acting on the group itself given by the inverse of a RightGroupOperation $σ_h$ as
\[τ_h(g) \coloneqq σ_h^{-1}(g) = σ(h^{-1},g) = g∘h^{-1}\]
Note that while in naming it is the inverse of the right action, it's properties yield that is is an AbstractLeftGroupActionType, since
\[τ_g(τ_h(p))
+τ_{hg}(p).\]
for its inverse $(σ_h)^{-1}$ see InverseLeftGroupOperation.
Note Some literature also calls this by itself the right group operation action.
sourceLieGroups.InverseRightGroupOperation — TypeInverseRightGroupOperation <: AbstractLeftGroupActionType
A type for the AbstractLeftGroupActionType when acting on the group itself given by the inverse of a RightGroupOperation $σ_h$ as
\[τ_h(g) \coloneqq σ_h^{-1}(g) = σ(h^{-1},g) = g∘h^{-1}\]
Note that while in naming it is the inverse of the right action, it's properties yield that is is an AbstractLeftGroupActionType, since
\[τ_g(τ_h(p))
= σ^{\mathrm R}_{g^{-1}}(σ^{\mathrm R}_{h^{-1}}(p))
= σ^{\mathrm R}_{h^{-1}g^{-1}}(p)
= σ^{\mathrm R}_{(gh)^{-1}}(p)
-τ_{gh}(p).\]
for its inverse $(σ_h)^{-1}$ see InverseLeftGroupOperation.
sourceLieGroups.LeftGroupOperation — TypeLeftGroupOperation <: AbstractLeftGroupActionType
A type for the AbstractLeftGroupActionType when acting on the group itself from the left, that is
\[σ_h(g) = σ(h,g) = h∘g\]
for its inverse $(σ_h)^{-1}$ see InverseLeftGroupOperation.
sourceLieGroups.RightGroupOperation — TypeRightGroupOperation <: AbstractRightGroupActionType
A type for the AbstractLeftGroupActionType when acting on the group itself gfrom the right
\[σ_h(g) = σ(h,g) = g∘h\]
for its inverse $(σ_h)^{-1}$ see InverseRightGroupOperation.
sourceBase.inv — Methodinv(::GroupOperationAction)
return the inverse group operation action, that is, use the type representing the inverse operation.
sourceBase.inv — Methodinv(::InverseLeftGroupOperation)
Return the inverse of the InverseLeftGroupOperation, that is the LeftGroupOperation.
sourceBase.inv — Methodinv(::InverseRightGroupOperation)
Return the inverse of the InverseRightGroupOperation, that is the RightGroupOperation.
sourceBase.inv — Methodinv(::LeftGroupOperation)
Return the inverse of the LeftGroupOperation, that is the InverseLeftGroupOperation.
sourceBase.inv — Methodinv(::RightGroupOperation)
Return the inverse of the RightGroupOperation, that is the InverseRightGroupOperation.
sourceLieGroups.diff_apply! — MethodCompute the differential $D_g σ_p(g): T_g\mathcal G → T_{σ_p(g)}\mathcal M$ of a group operation action, that is
- for the
LeftGroupOperation this calls diff_left_compose(G, g, h, X) - for the
RightGroupOperation this calls diff_right_compose(G, g, h, X) - for the
InverseLeftGroupOperation this calls diff_left_compose with $g^{-1}$ - for the
InverseRightGroupOperation this calls diff_right_compose with $g^{-1}$
sourceLieGroups.diff_apply — MethodCompute the differential $D_g σ_p(g): T_g\mathcal G → T_{σ_p(g)}\mathcal M$ of a group operation action, that is
- for the
LeftGroupOperation this calls diff_left_compose(G, g, h, X) - for the
RightGroupOperation this calls diff_right_compose(G, g, h, X) - for the
InverseLeftGroupOperation this calls diff_left_compose with $g^{-1}$ - for the
InverseRightGroupOperation this calls diff_right_compose with $g^{-1}$
sourceLieGroups.switch — Methodswitch(::InverseLeftGroupOperation)
Return the InverseRightGroupOperation, that is, turns $σ_g = g^{-1}∘h$ into $τ_g(h) = h∘g^{-1}$
sourceLieGroups.switch — Methodswitch(::InverseRightGroupOperation)
Return the InverseLeftGroupOperation, that is, turns $σ_g = h∘g^{-1}$ into $τ_g(h) = g^{-1}∘h$
sourceLieGroups.switch — Methodswitch(::LeftGroupOperation)
Return the RightGroupOperation, that is, turns $σ_g = g∘h$ into $τ_g(h) = h∘g$
sourceLieGroups.switch — Methodswitch(::RightGroupOperation)
Return the LeftGroupOperation, that is, turns $σ_g = h∘g$ into $τ_g(h) = g∘h$
sourceManifolds.apply! — Methodapply(A::GroupOperationAction, g, h)
-apply!(A::GroupOperationAction, k, g, h)
apply the stored group operation action, using compose $∘$. this can be done in-place of k.
sourceManifolds.apply — Methodapply(A::GroupOperationAction, g, h)
-apply!(A::GroupOperationAction, k, g, h)
apply the stored group operation action, using compose $∘$. this can be done in-place of k.
sourceFunctions on Lie Algebras
LieGroups.lie_bracket — Functionlie_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 holds $[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.
sourceLieGroups.lie_bracket! — Functionlie_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 holds $[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.
sourceSpecific Group Operations
For some generic group operations, an easy generic implementation can be provided. This section lists these specific cases and what is implemented for these.
Additive Group operation
LieGroups.AdditionGroupOperation — TypeAdditionGroupOperation <: AbstractGroupOperation
A group operation that is realised introducing defaults that fall back to + and - being overloaded, for example compose(G::LieGroup{𝔽,M,AdditionGroupOperation}, a,b) = a+b
sourceMultiplicative Group operation
Literature
- [HN12]
- J. Hilgert and K.-H. Neeb. Structure and Geometry of Lie Groups (Springer Monographs in Mathematics, 2012).
Settings
This document was generated with Documenter.jl version 1.7.0 on Wednesday 9 October 2024. Using Julia version 1.10.5.
for its inverse $(σ_h)^{-1}$ see InverseLeftGroupOperation.
LieGroups.LeftGroupOperation — TypeLeftGroupOperation <: AbstractLeftGroupActionTypeA type for the AbstractLeftGroupActionType when acting on the group itself from the left, that is
\[σ_h(g) = σ(h,g) = h∘g\]
for its inverse $(σ_h)^{-1}$ see InverseLeftGroupOperation.
LieGroups.RightGroupOperation — TypeRightGroupOperation <: AbstractRightGroupActionTypeA type for the AbstractLeftGroupActionType when acting on the group itself gfrom the right
\[σ_h(g) = σ(h,g) = g∘h\]
for its inverse $(σ_h)^{-1}$ see InverseRightGroupOperation.
Base.inv — Methodinv(::GroupOperationAction)return the inverse group operation action, that is, use the type representing the inverse operation.
Base.inv — Methodinv(::InverseLeftGroupOperation)Return the inverse of the InverseLeftGroupOperation, that is the LeftGroupOperation.
Base.inv — Methodinv(::InverseRightGroupOperation)Return the inverse of the InverseRightGroupOperation, that is the RightGroupOperation.
Base.inv — Methodinv(::LeftGroupOperation)Return the inverse of the LeftGroupOperation, that is the InverseLeftGroupOperation.
Base.inv — Methodinv(::RightGroupOperation)Return the inverse of the RightGroupOperation, that is the InverseRightGroupOperation.
LieGroups.diff_apply! — MethodCompute the differential $D_g σ_p(g): T_g\mathcal G → T_{σ_p(g)}\mathcal M$ of a group operation action, that is
LeftGroupOperation this calls diff_left_compose(G, g, h, X)RightGroupOperation this calls diff_right_compose(G, g, h, X)InverseLeftGroupOperation this calls diff_left_compose with $g^{-1}$InverseRightGroupOperation this calls diff_right_compose with $g^{-1}$LieGroups.diff_apply — MethodCompute the differential $D_g σ_p(g): T_g\mathcal G → T_{σ_p(g)}\mathcal M$ of a group operation action, that is
LeftGroupOperation this calls diff_left_compose(G, g, h, X)RightGroupOperation this calls diff_right_compose(G, g, h, X)InverseLeftGroupOperation this calls diff_left_compose with $g^{-1}$InverseRightGroupOperation this calls diff_right_compose with $g^{-1}$LieGroups.switch — Methodswitch(::InverseLeftGroupOperation)Return the InverseRightGroupOperation, that is, turns $σ_g = g^{-1}∘h$ into $τ_g(h) = h∘g^{-1}$
LieGroups.switch — Methodswitch(::InverseRightGroupOperation)Return the InverseLeftGroupOperation, that is, turns $σ_g = h∘g^{-1}$ into $τ_g(h) = g^{-1}∘h$
LieGroups.switch — Methodswitch(::LeftGroupOperation)Return the RightGroupOperation, that is, turns $σ_g = g∘h$ into $τ_g(h) = h∘g$
LieGroups.switch — Methodswitch(::RightGroupOperation)Return the LeftGroupOperation, that is, turns $σ_g = h∘g$ into $τ_g(h) = g∘h$
Manifolds.apply! — Methodapply(A::GroupOperationAction, g, h)
+apply!(A::GroupOperationAction, k, g, h)apply the stored group operation action, using compose $∘$. this can be done in-place of k.
Manifolds.apply — Methodapply(A::GroupOperationAction, g, h)
+apply!(A::GroupOperationAction, k, g, h)apply the stored group operation action, using compose $∘$. this can be done in-place of k.
LieGroups.lie_bracket — Functionlie_bracket!(𝔤::LieAlgebra, X, Y)
+lie_bracket!(𝔤::LieAlgebra, Z, X, Y)Compute the Lie bracket $[⋅,⋅]: \mathfrak g×\mathfrak g → \mathfrak g$ which fulfills
The computation can be done in-place of Z.
LieGroups.lie_bracket! — Functionlie_bracket!(𝔤::LieAlgebra, X, Y)
+lie_bracket!(𝔤::LieAlgebra, Z, X, Y)Compute the Lie bracket $[⋅,⋅]: \mathfrak g×\mathfrak g → \mathfrak g$ which fulfills
The computation can be done in-place of Z.
For some generic group operations, an easy generic implementation can be provided. This section lists these specific cases and what is implemented for these.
LieGroups.AdditionGroupOperation — TypeAdditionGroupOperation <: AbstractGroupOperationA group operation that is realised introducing defaults that fall back to + and - being overloaded, for example compose(G::LieGroup{𝔽,M,AdditionGroupOperation}, a,b) = a+b
Settings
This document was generated with Documenter.jl version 1.7.0 on Friday 11 October 2024. Using Julia version 1.10.5.
All notable Changes to the Julia package LieGroups.jl will be documented in this file.
The format is based on Keep a Changelog, and this project adheres to Semantic Versioning.
Everything denoted by “formerly” refers to the previous name in Manifolds.jl.
LieAlgebraLieGroup (formerly GroupManifold) as well as the concrete groupsAdditiveGroup (formerly TranslationGroup)AbstractGroupOperation as well as its concrete subtypesAdditionGroupOperation (formerly AdditionOperation)AbstractGroupActionType with its 2 specific (new) abstractAbstractLeftGroupActionTypeAbstractRightGroupActionTypeLeftGroupOperation (formerly LeftForwardAction)RightGroupOperation (formerly RightBackwardAction)InverseLeftGroupOperation (formerly RightForwardAction)InverseRightGroupOperation (formerly LeftBackwardAction)applyand apply!base_manifold to access the manifold within a Lie groupcompose and compose!conjugate and conjugate!diff_apply, diff_apply!, diff_group_apply, and diff_group_apply! (formerly apply_diff_[group][!])diff_left_compose, diff_left_compose!, diff_right_compose, diff_right_compose! (formerly translate_diff with different sides)exp(G::LieGroup, g, X) and exp!(G::LieGroup, h, g, X) (formerly exp_inv and exp_inv!)exp(G::LieGroup, ::Identity, X) and exp!(G::LieGroup, h, ::Identity, X) (formerly exp_lie and exp_lie!)Identityidenity_element and identity_element!inv and inv! (inv(::AbstractGroupAction) was formerly switch_direction)inv_left_compose, inv_left_compose! and inv_right_compose, inv_right_compose! (these functions correspond to inverse_translate with corresponding direction and side)is_identityLie_bracket and Lie_bracket! (formerly lie_bracket)log(G::LieGroup, g, h) and log!(G::LieGroup, X, g, h) (formerly log_inv and log_inv!)log(G::LieGroup, ::Identity, g) and log!(G::LieGroup, X, ::Identity, g) (formerly log_lie and log_lie!)switch (formerly switch_side)Compared to Manifolds.jl
translate functions are not implemented here, since you can just use compose. The differentials are implemented as listed above with respect to both left and right argument of composeinverse_apply functions are not implemented here, since it is recommended to use apply(inv(A), g, p) as a replacement.Two previous releases where done by Yueh-Hua Tu in 2022 before he was so kind to transfer the development to the JuliaManifolds GitHub organisation.
All notable changes to this project will be documented in this file.
Settings
This document was generated with Documenter.jl version 1.7.0 on Wednesday 9 October 2024. Using Julia version 1.10.5.
All notable Changes to the Julia package LieGroups.jl will be documented in this file.
The format is based on Keep a Changelog, and this project adheres to Semantic Versioning.
Everything denoted by “formerly” refers to the previous name in Manifolds.jl.
LieAlgebraLieGroup (formerly GroupManifold) as well as the concrete groupsAdditiveGroup (formerly TranslationGroup)AbstractGroupOperation as well as its concrete subtypesAdditionGroupOperation (formerly AdditionOperation)AbstractGroupActionType with its 2 specific (new) abstractAbstractLeftGroupActionTypeAbstractRightGroupActionTypeLeftGroupOperation (formerly LeftForwardAction)RightGroupOperation (formerly RightBackwardAction)InverseLeftGroupOperation (formerly RightForwardAction)InverseRightGroupOperation (formerly LeftBackwardAction)applyand apply!base_manifold to access the manifold within a Lie groupcompose and compose!conjugate and conjugate!diff_apply, diff_apply!, diff_group_apply, and diff_group_apply! (formerly apply_diff_[group][!])diff_left_compose, diff_left_compose!, diff_right_compose, diff_right_compose! (formerly translate_diff with different sides)exp(G::LieGroup, g, X) and exp!(G::LieGroup, h, g, X) (formerly exp_inv and exp_inv!)exp(G::LieGroup, ::Identity, X) and exp!(G::LieGroup, h, ::Identity, X) (formerly exp_lie and exp_lie!)Identityidenity_element and identity_element!inv and inv! (inv(::AbstractGroupAction) was formerly switch_direction)inv_left_compose, inv_left_compose! and inv_right_compose, inv_right_compose! (these functions correspond to inverse_translate with corresponding direction and side)is_identityLie_bracket and Lie_bracket! (formerly lie_bracket)log(G::LieGroup, g, h) and log!(G::LieGroup, X, g, h) (formerly log_inv and log_inv!)log(G::LieGroup, ::Identity, g) and log!(G::LieGroup, X, ::Identity, g) (formerly log_lie and log_lie!)switch (formerly switch_side)Compared to Manifolds.jl
translate functions are not implemented here, since you can just use compose. The differentials are implemented as listed above with respect to both left and right argument of composeinverse_apply functions are not implemented here, since it is recommended to use apply(inv(A), g, p) as a replacement.Two previous releases where done by Yueh-Hua Tu in 2022 before he was so kind to transfer the development to the JuliaManifolds GitHub organisation.
All notable changes to this project will be documented in this file.
Settings
This document was generated with Documenter.jl version 1.7.0 on Friday 11 October 2024. Using Julia version 1.10.5.
For most of the notation used throughout this package, we follow [HN12]
| Symbol | Description | Also used | Comment |
|---|---|---|---|
| $∘$ | a group operation | ||
| $c:\mathcal G → \mathcal G, c_g$ | the conjugation map (with g) | ||
| $\mathrm{e}$ | identity element of a group | ||
| $g, h, k$ | elements on a (Lie) group. Sometimes called points. | $g_1, g_2, ...$ | |
| $\mathfrak g$ | a Lie algebra | ||
| $\mathcal{G}$ | a (Lie) group | ||
| $λ_g: \mathcal G → \mathcal G$ | the left multiplication map $λ_g(h) = g∘h$ | ||
| $\mathcal M$ | a manifold | $\mathcal M_1, \mathcal M_2,\ldots,\mathcal N$ | |
| $\operatorname{Exp}$ | the matrix exponential | ||
| $\operatorname{Log}$ | the matrix logarithm | ||
| $ρ_g: \mathcal G → \mathcal G$ | the right multiplication map $ρ_g(h) = h∘g$ | ||
| $σ: \mathcal G × \mathcal M$ | a left group action | we use $σ_g(p)$ if the group element is fixed | |
| $τ: \mathcal M × \mathcal G$ | a right group action | $σ_\mathrm{R}$ | we use $τ_g(p)$ if the group element is fixed |
| $T_p \mathcal M$ | the tangent space at $p$ |
Settings
This document was generated with Documenter.jl version 1.7.0 on Wednesday 9 October 2024. Using Julia version 1.10.5.
For most of the notation used throughout this package, we follow [HN12]
| Symbol | Description | Also used | Comment |
|---|---|---|---|
| $∘$ | a group operation | ||
| $c:\mathcal G → \mathcal G, c_g$ | the conjugation map (with g) | ||
| $\mathrm{e}$ | identity element of a group | ||
| $g, h, k$ | elements on a (Lie) group. Sometimes called points. | $g_1, g_2, ...$ | |
| $\mathfrak g$ | a Lie algebra | ||
| $\mathcal{G}$ | a (Lie) group | ||
| $λ_g: \mathcal G → \mathcal G$ | the left multiplication map $λ_g(h) = g∘h$ | ||
| $\mathcal M$ | a manifold | $\mathcal M_1, \mathcal M_2,\ldots,\mathcal N$ | |
| $\operatorname{Exp}$ | the matrix exponential | ||
| $\operatorname{Log}$ | the matrix logarithm | ||
| $ρ_g: \mathcal G → \mathcal G$ | the right multiplication map $ρ_g(h) = h∘g$ | ||
| $σ: \mathcal G × \mathcal M$ | a left group action | we use $σ_g(p)$ if the group element is fixed | |
| $τ: \mathcal M × \mathcal G$ | a right group action | $σ_\mathrm{R}$ | we use $τ_g(p)$ if the group element is fixed |
| $T_p \mathcal M$ | the tangent space at $p$ |
Settings
This document was generated with Documenter.jl version 1.7.0 on Friday 11 October 2024. Using Julia version 1.10.5.
This is all literature mentioned / referenced in the LieGroups.jl documentation. Usually you find a small reference section at the end of every documentation page that contains the corresponding references as well.
Settings
This document was generated with Documenter.jl version 1.7.0 on Wednesday 9 October 2024. Using Julia version 1.10.5.
This is all literature mentioned / referenced in the LieGroups.jl documentation. Usually you find a small reference section at the end of every documentation page that contains the corresponding references as well.
Settings
This document was generated with Documenter.jl version 1.7.0 on Friday 11 October 2024. Using Julia version 1.10.5.
Settings
This document was generated with Documenter.jl version 1.7.0 on Wednesday 9 October 2024. Using Julia version 1.10.5.
Settings
This document was generated with Documenter.jl version 1.7.0 on Friday 11 October 2024. Using Julia version 1.10.5.