Transition from GroupManifolds in Manifolds.jl
One predecessor of LieGroups.jl are the GroupManifolds in Manifolds.jl. While this package provides the same features, one reason for a new package is, that a “restart” offers the opportunity to put the main focus for the functions in this package really on Lie groups.
This tutorial provides an overview of the necessary changes to your code if you based it on the predecessor.
Table of function names and its successors
The following table lists all functions related to GroupManifolds and their new names or replacements here in LieGroups.jl. In this code G always refers to the GroupManifold in the first column and the LieGroup in the second. Lie group elements (points) are always g,h, Lie algebra elements (vectors) always X, Y.
New functions and types in this package are only mentioned, if they are worth a comment and if something changed.
The list is alphabetical, but first lists types, then functions
Manifolds.jl | LieGroups.jl | Comment |
|---|---|---|
AdditionOperation | AdditionGroupOperation | |
LeftForwardAction | LeftGroupOperationAction | |
RightBackwardAction | RightGroupOperationAction | |
LeftBackwardAction | InverseRightGroupOperationAction | note that this is now also aa AbstractLeftGroupActionType |
LieAlgebra(G) | new alias to emphasize its manifold- and vector structure as well as for a few dispatch methods. | |
GroupManifold(M, op) | LieGroup(M, op) | |
PowerGroup(M) | PowerLieGroup(G,n) | The main change is, that the constructor now requires a Lie group to build the power Lie group; This also allows for G^n. The other two former constructors for nested and nested-replacing are no longer necessary. PowerLieGroup behaves exactly the same as PowerManifold. |
ProductGroup(M) | ProductLieGroup(G, H) | The main change is, that the constructor now requires two Lie groups to build their product. This also allows for the short hand G×H to generate this product. |
SemidirectProductGroup(G, H, a) | LeftSemidirectProductLieGroup(G, H, a) | While this staid the same, there is now also the default_left_action(G,H). When this agrees with a you can use the short hand G⋉H to generate this semidirect product. Analogously there now also exists the RightSemidirectProductLieGroup(G,H) withdefault_left_action(G,H) that allows for the short cut G⋊H |
RightForwardAction | InverseLeftGroupOperationAction | note that this is an AbstractRightGroupActionType |
adjoint | adjoint | now implemented with a default, when you provide diff_conjugate!. |
apply_diff | diff_apply | modifiers (diff) come first, consistent with ManifoldsDiff.jl |
apply_diff_group | diff_group_apply | modifiers (diff/group) come first, consistent with ManifoldsDiff.jl |
conjugate, diff_conjugate | a new function to model $c_g: \mathcal G → \mathcal G$ given by $c_g(h) = g∘h∘g^{-1}$ | |
exp(G, g, X) | exp(base_manifold(G), g, X) | the previous defaults whenever not agreeing with the invariant one can now be accessed on the internal manifold |
exp_inv(G, g, X) | exp(G, g, X) | the exponential map invariant to the group operation is the default on Lie groups here |
exp_lie(G, X) | exp(G,Identity(G), X) | the (matrix) exponential is now the one at the Identity(G), since there it agrees with the invariant one |
inverse_translate(G, g, h, c) | inv_left_compose(G, g, h), inv_right_compose(G, g, h) | compute $g^{-1}∘h$ and $g∘h^{-1}$, resp. |
inverse_tranlsate_diff(G, g, h, X, LeftForwardAction()) | - | discontinued, use diff_left_compose(G, inv(G,g), h) |
inverse_tranlsate_diff(G, g, h, X, RightBackwardAction()) | - | discontinued, use diff_left_compose(G, h, inv(G,g)) |
log(G, g, h) | log(base_manifold(G), g, h) | you can now access the previous defaults on the internal manifold whenever they do not agree with the invariant one |
log_inv(G, g, h) | log(G, g, h) | the logarithmic map invariant to the group operation is the default on Lie groups here |
log_lie(G, g) | log(G,Identity(G), g) | the (matrix) logarithm is now the one at the identity, since there it agrees with the invariant one |
switch_direction(A) | inv(A) | switches from an action to its inverse action (formerly the direction forward/backward, sometimes even left/right, do not confuse with the side left/right). |
switch_side(A) | switch(A) | switches from a left action to its corresponding right action. |
translate(G, g, h) | compose(G, g, h) | unified to compose |
translate_diff(G, g, X, c) | diff_left_compose(G, g, h, X), diff_right_compose(G, g, h, X) | for compose $g∘h$ the functions now specify whether the derivative is taken w.r.t. to the left (g) or right (h) argument |
VeeOrthogonalBasis | LieAlgebraOrthogonalBasis |
Further notable changes
- The
GeneralLinearGroup(formerlyGeneralLinear) switched to using its Lie algebra to represent tangent vectors. - Formerly, both a power of LieGroups as well as a LieGroup on the power manifold was possible. This is now unified to the latter,
the operation for power manifolds can hence stay the same as for the single manifold.
- Formerly, product manifolds were stored as a
ProductManifoldof Lie groups and an indicator for the group operation, that the direct product should be used. This is switched to (as for the last point) internally only store aProductManifoldas well as a (new)ProductGroupOperationthat specifies one group operation for every factor. - both the last two points achieve one unified modelling aspect of Lie groups: They are now always a Riemannian manifold
Mtogether with a group operationop,
but a Lie group does not store another Lie group (or product of them) internally.