Fixes

src/groups/group.jl

@@ -918,7 +918,7 @@ function inverse_translate_diff(
     conv::ActionDirectionAndSide,
 )
     BG = base_group(G)
-    return translate_diff(BG, inv(BG, p), q, inv_diff(BG, p, X), conv)
+    return translate_diff(BG, inv(BG, p), q, X, conv)
 end
 
 @trait_function inverse_translate_diff!(
@@ -939,7 +939,7 @@ function inverse_translate_diff!(
     conv::ActionDirectionAndSide,
 )
     BG = base_group(G)
-    return translate_diff!(BG, Y, inv(BG, p), q, inv_diff(BG, p, X), conv)
+    return translate_diff!(BG, Y, inv(BG, p), q, X, conv)
 end
 
 @doc raw"""

src/groups/group_operation_action.jl

@@ -65,12 +65,48 @@ end
 
 function adjoint_apply_diff_group(A::GroupOperationAction, a, X, p)
     G = base_group(A)
-    return inverse_translate_diff(G, a, p, X, reverse_direction_and_side(A))
+    if direction_and_side(A) === LeftForwardAction() ||
+       direction_and_side(A) === RightBackwardAction()
+        return inverse_translate_diff(
+            G,
+            a,
+            p,
+            X,
+            (direction(A), switch_side(action_side(A))),
+        )
+    else
+        return inverse_translate_diff(
+            G,
+            p,
+            a,
+            inv_diff(G, a, X),
+            (direction(A), switch_side(action_side(A))),
+        )
+    end
 end
 
 function adjoint_apply_diff_group!(A::GroupOperationAction, Y, a, X, p)
     G = base_group(A)
-    return inverse_translate_diff!(G, Y, a, p, X, reverse_direction_and_side(A))
+    if direction_and_side(A) === LeftForwardAction() ||
+       direction_and_side(A) === RightBackwardAction()
+        return inverse_translate_diff!(
+            G,
+            Y,
+            a,
+            p,
+            X,
+            (direction(A), switch_side(action_side(A))),
+        )
+    else
+        return inverse_translate_diff!(
+            G,
+            Y,
+            p,
+            a,
+            inv_diff(G, a, X),
+            (direction(A), switch_side(action_side(A))),
+        )
+    end
 end
 
 apply(A::GroupOperationAction, a, p) = translate(A.group, a, p, direction_and_side(A))

src/groups/multiplication_operation.jl

@@ -23,6 +23,8 @@ Base.:\(p, ::Identity{MultiplicationOperation}) = inv(p)
 Base.:\(::Identity{MultiplicationOperation}, p) = p
 Base.:\(e::Identity{MultiplicationOperation}, ::Identity{MultiplicationOperation}) = e
 
+Base.inv(e::Identity{MultiplicationOperation}) = e
+
 LinearAlgebra.det(::Identity{MultiplicationOperation}) = true
 LinearAlgebra.adjoint(e::Identity{MultiplicationOperation}) = e
 
@@ -132,7 +134,16 @@ The formula reads ``-p^{-1}Xp^{-1}``.
 """
 function inv_diff(::MultiplicationGroupTrait, G::AbstractDecoratorManifold, p, X)
     p_inv = inv(p)
-    return -p_inv * X * p_inv
+    return -(p_inv * X * p_inv)
+end
+function inv_diff(
+    ::MultiplicationGroupTrait,
+    G::AbstractDecoratorManifold,
+    p::AbstractArray{<:Number,0},
+    X::AbstractArray{<:Number,0},
+)
+    p_inv = inv(p[])
+    return -(p_inv * X * p_inv)
 end
 function inv_diff!(::MultiplicationGroupTrait, G::AbstractDecoratorManifold, Y, p, X)
     p_inv = inv(p)

src/groups/power_group.jl

@@ -128,6 +128,20 @@ function inv!(
     return q
 end
 
+function inv_diff!(G::PowerGroup, Y, p, X)
+    GM = G.manifold
+    rep_size = representation_size(GM.manifold)
+    for i in get_iterator(GM)
+        inv_diff!(
+            GM,
+            _write(GM, rep_size, Y, i),
+            _read(GM, rep_size, p, i),
+            _read(GM, rep_size, X, i),
+        )
+    end
+    return Y
+end
+
 # lower level methods are added instead of top level ones to not have to deal
 # with `Identity` disambiguation
 

src/groups/product_group.jl

@@ -102,6 +102,18 @@ function inv!(G::ProductGroup, q, p)
 end
 inv!(::ProductGroup, q::Identity{ProductOperation}, ::Identity{ProductOperation}) = q
 
+function inv_diff!(G::ProductGroup, Y, p, X)
+    M = G.manifold
+    map(
+        inv_diff!,
+        M.manifolds,
+        submanifold_components(G, Y),
+        submanifold_components(G, p),
+        submanifold_components(G, X),
+    )
+    return Y
+end
+
 _compose(G::ProductGroup, p, q) = _compose(G.manifold, p, q)
 function _compose(M::ProductManifold, p::ArrayPartition, q::ArrayPartition)
     return ArrayPartition(