LinearODETpl fails with non-Euclidean state due to strict A.cols() == space->ndx() constraint

[Zionshang]

The current implementation of aligator::dynamics::LinearODETpl strictly requires that the number of columns of matrix A matches the manifold tangent dimension space->ndx(), as enforced in the constructor:

if (A.cols() != space->ndx()) {
  ALIGATOR_DOMAIN_ERROR(
      "A.cols() should be equal to space.ndx()! (got {:d} and {:d})",
      A.cols(), space->ndx());
}

However, this becomes problematic during execution because the forward() method performs:

data.xdot_ = A_ * x + B_ * u + c_;

Here, x is passed directly as a state vector, and its dimension is typically nx, which may differ from space->ndx() especially when the state lives on a manifold (e.g., quaternions or SE(3)).

This mismatch between the expected input dimension of A_ and the actual size of x leads to dimension errors and makes LinearODETpl incompatible with many practical robotic systems.

[ManifoldFR]

Hello @Zionshang,

Yes, this is a known limitation! We never got around to thinking of a proper formulation and implementation of the linear ODE for general Lie groups.

My thinking was that most likely we'd want the trivialized vector field, and actual ODE dynamics to be something like

$$f(x, u) = A\log(x) + Bu + c \in \mathup{T}_e G, \dot x(t) = x(t) \cdot f(x(t), u(t)) \in \mathup{T}_{x(t)}G$$

where the $x \cdot $ term in the second equation would be the left-action (to bring the vector back to the tangent space at $x$). Not sure about the log though. Maybe something like a difference $x \ominus \bar{x}$?

But we never implemented or tested this in practice. If you need something like this we'd be happy to take a look at it in the future, perhaps with your help through a PR or A/B testing to speed the process up.

[Zionshang]

Thank you very much for the detailed and insightful response! 🙏

It’s good to know this is a known limitation, and I really appreciate the ideas you shared. I’ll definitely take some time to think about how such a formulation could be implemented in a simple and efficient way.

Thanks again for your helpful explanation and for the great work on this library!