Lie Bracket operation about manif HOT 8 OPEN

For all immplementation issues, @artivis is the man :-) but yes, it seems that in the Tangent base class we could add this implementation, it would become immediately available to all Tangent classes.

from manif.

Hello there,

This feature is indeed missing and would be a nice addition. However I'm not sure what the syntax would be at the moment. Let me play with it a little and I'll come back with a proposal.

from manif.

We did not implement the Lie bracket in manif. But I agree this could be a valuable tool, and it should be easy.

@artivis ?

Regarding the formulas, if I am not wrong the Lie bracket can be computed as [a,b] = a^ b^ - b^ a^ for all matrix Lie groups. Then, for some groups perhaps there exist simplified forms. The result is an element of the Lie Algebra. In manif, this element could be represented back into the Cartesian tangent space:

[ a, b ]v = (a^ b^ - b^ a^)v

where v is the vee operator, so we would have the general implementation as

LieGroupTangent a, b;
LieGroupTangent ab_bracket = ( a.hat() * b.hat() - b.hat() * a.hat() ).vee();

I am not fully sure of what I wrote here. If you can confirm this, then this would be possibly added to manif.

from manif.

The infos above are confirmed here

https://math.stackexchange.com/questions/460079/is-the-lie-bracket-of-a-lie-algebra-of-a-matrix-lie-group-always-the-commutator

and here

"The standard Lie bracket for Lie algebras of matrix Lie groups is given by [A, B] = AB − BA."

which can be found here:

http://www.math.uchicago.edu/~may/VIGRE/VIGRE2010/REUPapers/Turzillo.pdf

from manif.

Yes @joansola that seems right to me. I didn't realise that before, and i can use ( a.hat() * b.hat() - b.hat() * a.hat() ).vee() in the meantime for my application. I've had a chance to skim a couple textbooks (e.g. Barfoot's State Estimation for Robotics) and I believe this applies for matrix lie groups.

For reference, Sophus implements this as a static function in each lie group class, taking A and B as arguments and returning the simplified form of [A, B] for that group. I don't see the general commutator implementation above, perhaps because they don't need it.

manif uses CRTP rather than virtual polymorphism, so i'm not sure off the top of my head what the best implementation would be. Something equivalent to the general commutator in lie_group_base.h (or tangent_base.h) and simplified implmentations in each derived class.

from manif.

One additional note is that it would be convenient to have a lie bracket function on the lie algebra elements themselves, which would avoid recomputation / unnecessary mapping to/from the tangent vector in my case. Perhaps this could be an overload, or a different function. For example:

LieGroupTangent lie_bracket(const LieGroupTangent::LieAlg& A, const LieGroupTangent::LieAlg& B) {
    return (A * B - B * A).vee();
}
LieGroupTangent lie_bracket(const LieGroupTangent& a, const LieGroupTangent& b) {
    return lie_bracket(a.hat(), b.hat());
}

Implementation of course will differ, but this is the idea.

from manif.

One key issue is: we do not have a class for the LieAlgebra space apart from the TangentBase::LieAlg type, and so the vee() operator is missing in manif. I wonder whether it can be added to the TangentBase class, with an API like so:

static TangentBase vee( TangentBase::LieAlg _v_hat)
{
   TangentBase v;
   // build v from _v_hat
   return v;
}

or even from the constructor, with someting like

TangentBase::TangentBase(TangentBase::LieAlg _v_hat)
{
   // build v from _v_hat
   coeffs() = v;
}

from manif.

An additional note is that the lie bracket also equals $[X, Y] = adj(X)Y = XY - YX$. where $adj$ is the small adjoint. See section 10.2.6 equation 10.37 of "Stochastic Models, Information Theory, and Lie Groups, Vol 2".

I thought I would point this out since the small adjoint operation is already defined in code, but it may not help at all.

from manif.