Power, Product, and semidirect product manifolds

NEWS.md

@@ -15,16 +15,28 @@ Everything denoted by “formerly” refers to the previous name in [`Manifolds.
 * `LieGroup` (formerly `GroupManifold`) as well as the concrete groups
   * `TranslationGroup`
   * `GeneralLinearGroup` (formerly `GeneralLinear`)
+  * `LeftSemidirectProductLieGroup` (formerly `SemidirectProductGroup`)
+  * `⋉` (alias for `LeftSemidirectProductGroupOperation` when a `default_left_action(G,H)` is defined for the two groups)
+  * `PowerLieGroup` (formerly `PowerGroup`)
+  * `PowerGroupOperation` to internally avoid ambiguities. Since the constructor always expects a Lie group, this is only necessary internally
+  * `ProductLieGroup` (formerly `ProductGroup`)
+  * `RightSemidirectProductLieGroup`
+  * `⋊` (alias for `RightSemidirectProductGroupOperation` when a `default_right_action(G,H)` is defined for the two groups)
 * `AbstractGroupOperation` as well as its concrete subtypes
   * `AdditionGroupOperation` (formerly `AdditionOperation`)
+  * `MultiplicationGroupOperation` (formerly `MultiplicationOperation`)
+  * `PowerGroupOperation` (formerly the Lie group was stored inside a power manifold)
+  * `ProductGroupOperation` (formerly the Lie groups were stored inside a product manifold)
+  * `LeftSemidirectProductGroupOperation` (this was formerly only implicitly stored in the `SemidirectProductGroup`)
+  * `RightSemidirectProductGroupOperation`
 * `AbstractGroupActionType` with its 2 specific (new) abstract subtypes
   * `AbstractLeftGroupActionType`
   * `AbstractRightGroupActionType`
 * For the group operation actions there are now
-  * `LeftGroupOperation` (formerly `LeftForwardAction`)
-  * `RightGroupOperation` (formerly `RightBackwardAction`)
-  * `InverseLeftGroupOperation` (formerly `RightForwardAction`)
-  * `InverseRightGroupOperation` (formerly `LeftBackwardAction`)
+  * `LeftGroupOperationAction` (formerly `LeftForwardAction`)
+  * `RightGroupOperationAction` (formerly `RightBackwardAction`)
+  * `InverseLeftGroupOperationAction` (formerly `RightForwardAction`)
+  * `InverseRightGroupOperationAction` (formerly `LeftBackwardAction`)
 * `LieAlgebraOrthogonalBasis` (replaces `VeeOrthogonalBasis`, which is still available in `ManifoldsBase.jl`)
 * `Identity`
 * `apply`and `apply!`

Project.toml

@@ -14,14 +14,16 @@ Aqua = "0.8"
 LinearAlgebra = "1.6"
 Manifolds = "0.10.5"
 ManifoldsBase = "0.15.20"
+RecursiveArrayTools = "2, 3"
 Random = "1.6"
 Test = "1.6"
 julia = "1.6"
 
 [extras]
 Aqua = "4c88cf16-eb10-579e-8560-4a9242c79595"
 Manifolds = "1cead3c2-87b3-11e9-0ccd-23c62b72b94e"
+RecursiveArrayTools = "731186ca-8d62-57ce-b412-fbd966d074cd"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 
 [targets]
-test = ["Test", "Aqua", "Manifolds"]
+test = ["Test", "Aqua", "Manifolds", "RecursiveArrayTools"]

docs/make.jl

@@ -125,6 +125,9 @@ makedocs(;
         "Lie groups" => [
             "List of Lie groups" => "groups/index.md",
             "General Linear" => "groups/general_linear.md",
+            "Power group" => "groups/power_group.md",
+            "Product group" => "groups/product_group.md",
+            "Semidirect product group" => "groups/semidirect_product_group.md",
             "Translation group" => "groups/translation.md",
         ],
         "Interfaces" => [

docs/src/groups/power_group.md

@@ -0,0 +1,7 @@
+# The power Lie group
+
+```@autodocs
+Modules = [LieGroups]
+Pages = ["groups/power_group.jl"]
+Order = [:type, :function]
+```

docs/src/groups/product_group.md

@@ -0,0 +1,7 @@
+# The product Lie group
+
+```@autodocs
+Modules = [LieGroups]
+Pages = ["groups/product_group.jl"]
+Order = [:type, :function]
+```

docs/src/groups/semidirect_product_group.md

@@ -0,0 +1,7 @@
+# The semidirect product Lie group
+
+```@autodocs
+Modules = [LieGroups]
+Pages = ["groups/semidirect_product_group.jl"]
+Order = [:type, :function]
+```

docs/src/tutorials/transition.md

@@ -22,12 +22,15 @@ The list is alphabetical, but first lists types, then functions
 | `Manifolds.jl` | `LieGroups.jl` | Comment |
 |:---------- |:---------- |:-------------- |
 | `AdditionOperation` | [`AdditionGroupOperation`](@ref) | |
-| `LeftForwardAction` | [`LeftGroupOperation`](@ref)
-| `RightBackwardAction` | [`RightGroupOperation`](@ref) | |
-| `LeftBackwardAction` | [`InverseRightGroupOperation`](@ref) | note that this is now also aa [`AbstractLeftGroupActionType`](@ref) |
+| `LeftForwardAction` | [`LeftGroupOperationAction`](@ref)
+| `RightBackwardAction` | [`RightGroupOperationAction`](@ref) | |
+| `LeftBackwardAction` | [`InverseRightGroupOperationAction`](@ref) | note that this is now also aa [`AbstractLeftGroupActionType`](@ref) |
 | | [`LieAlgebra`](@ref)`(G)` | new alias to emphasize its manifold- and vector structure as well as for a few dispatch methods. |
 | `GroupManifold(M, op)` | [`LieGroup`](@ref)`(M, op)` | |
-| `RightForwardAction` | [`InverseLeftGroupOperation`](@ref) | note that this is an [`AbstractRightGroupActionType`](@ref) |
+| `PowerGroup(M)` | [`PowerLieGroup`](@ref)`(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`](@extref `ManifoldsBase.PowerManifold`). |
+| `ProductGroup(M)` | [`ProductLieGroup`](@ref)`(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`](@ref)`(G, H, a)` | While this staid the same, there is now also the [`default_left_action`](@ref)`(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`](@ref)`(G,H)` with[`default_left_action`](@ref)`(G,H)` that allows for the short cut `G⋊H` |
+| `RightForwardAction` | [`InverseLeftGroupOperationAction`](@ref) | note that this is an [`AbstractRightGroupActionType`](@ref) |
 | `adjoint` | [`adjoint`](@ref) | now implemented with a default, when you provide [`diff_conjugate!`](@ref).
 | `apply_diff` | [`diff_apply`](@ref) | modifiers (diff) come first, consistent with [`ManifoldsDiff.jl`](https://juliamanifolds.github.io/ManifoldDiff.jl/stable/) |
 | `apply_diff_group` | [`diff_group_apply`](@ref) | modifiers (diff/group) come first, consistent with [`ManifoldsDiff.jl`](https://juliamanifolds.github.io/ManifoldDiff.jl/stable/) |
@@ -41,12 +44,17 @@ The list is alphabetical, but first lists types, then functions
 | `log(G, g, h)` | `log(`[`base_manifold`](@ref base_manifold(G::LieGroup))`(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`](@ref log(G::LieGroup, g, h))`(G, g, h)` | the logarithmic map invariant to the group operation is the default on Lie groups here |
 | `log_lie(G, g)` | [`log`](@ref log(G::LieGroup, e::Identity, g))`(G, `[`Identity`](@ref)`(G), g)` | the (matrix) logarithm is now the one at the identity, since there it agrees with the invariant one |
-| `switch_direction(A)` | [`inv`](@ref inv(::AbstractGroupAction))`(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`](@ref switch(::AbstractGroupAction))`(A)` | switches from a left action to its corresponding right action. |
+| `switch_direction(A)` | [`inv`](@ref inv(::GroupAction))`(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`](@ref switch(::GroupAction))`(A)` | switches from a left action to its corresponding right action. |
 | `translate(G, g, h)` | [`compose`](@ref)`(G, g, h)` | unified to `compose` |
 | `translate_diff(G, g, X, c)` | [`diff_left_compose`](@ref)`(G, g, h, X)`, [`diff_right_compose`](@ref)`(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`](@ref) | |
 
-# Notable changes
+# Further notable changes
 
-* The [`GeneralLinearGroup`](@ref) (formerly `GeneralLinear`) switched to using its Lie algebra to represent tangent vectors.
+1. The [`GeneralLinearGroup`](@ref) (formerly `GeneralLinear`) switched to using its Lie algebra to represent tangent vectors.
+2. 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.
+3. Formerly, product manifolds were stored as a [`ProductManifold`](@extref) of 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 a [`ProductManifold`](@extref) as well as a (new) [`ProductGroupOperation`](@ref) that specifies one group operation for every factor.
+4. both the last two points achieve one unified modelling aspect of Lie groups: They are now always a Riemannian manifold `M` together with a group operation `op`,
+but a Lie group does not store another Lie group (or product of them) internally.

docs/styles/config/vocabularies/LieGroups/accept.txt

@@ -1,8 +1,8 @@
-julia
-Julia
+[jJ]ulia
 LieGroups.jl
 Lie algebra
 Lie algebras
 Lie group
 Lie groups
-Riemannian
+Riemannian
+semidirect

src/LieGroups.jl

@@ -32,29 +32,37 @@ include("group_operations/multiplication_operation.jl")
 include("group_actions/group_action_interface.jl")
 include("group_actions/group_operation_action.jl")
 
+# Meta Lie groups
+include("groups/power_group.jl")
+include("groups/product_group.jl")
+include("groups/semidirect_product_group.jl")
 # Lie groups
 include("groups/translation_group.jl")
 include("groups/general_linear_group.jl")
 
 export LieGroup, LieAlgebra
+export PowerLieGroup, ProductLieGroup
+export LeftSemidirectProductLieGroup, RightSemidirectProductLieGroup
 export LieAlgebraOrthogonalBasis
+export ×, ^, ⋉, ⋊
 #
 #
 # Group Operations
 export AbstractGroupOperation, Identity
 export AdditionGroupOperation
 export AbstractMultiplicationGroupOperation
 export MatrixMultiplicationGroupOperation
+export ProductGroupOperation
+export LeftSemidirectProductGroupOperation, RightSemidirectProductGroupOperation
 
 #
 #
 # Group Actions
-export AbstractGroupActionType, AbstractGroupAction
+export AbstractGroupActionType
 export AbstractLeftGroupActionType, AbstractRightGroupActionType
-export LeftGroupOperation, RightGroupOperation
-export InverseLeftGroupOperation, InverseRightGroupOperation
-export GroupOperationAction
-
+export LeftGroupOperationAction, RightGroupOperationAction
+export InverseLeftGroupOperationAction, InverseRightGroupOperationAction
+export GroupAction, GroupOperationAction
 #
 #
 # Specific groups
@@ -63,7 +71,9 @@ export TranslationGroup, GeneralLinearGroup
 export adjoint, adjoint!, apply, apply!
 export base_lie_group, base_manifold
 export compose, compose!
-export det,
+export default_left_action,
+    default_right_action,
+    det,
     diff_apply,
     diff_apply!,
     diff_group_apply,