Lie Algebra on SO3 Groups in Python

Curious about manifolds and the SO(3) Lie group??

Your next step is to explore its associated Lie algebra, which lies in the tangent space. This algebra is a linear space with the same dimension as the Lie group, closed under a bilinear alternating operation known as the Lie bracket. The Lie algebra of SO(3), denoted as so3, consists of all 3x3 skew-symmetric matrices.

What you will learn:?How to compute SO3 rotation matrices from tangent vector and extract Lie algebra from points on SO3 manifolds.

Notes:?

• This post is a follow up on a previous post on SO3 Lie groups?[ref?1] and leverage articles related to differential geometry and geometry learning [ref?2,?3,?4?and?5]
• Environments:?Python 3.11, ?Matplotlib 3.9, Geomstats 2.8.0
• Source code is available at ?Github.com/patnicolas/Data_Exploration/Lie
• To enhance the readability of the algorithm implementations, we have omitted non-essential code elements like error checking, comments, exceptions, validation of class and method arguments, scoping qualifiers, and import statement.

Disclaimer?:?A thorough tutorial and explanation of Lie groups, Lie algebras, and geometric priors for deep learning models is beyond the scope of this article. Instead, the following sections concentrate on experimenting with the Lie Algebra on 3-dimension Special Orthogonal manifolds using the?Geomstats?Python library [ref?6].

Lie algebra on?SO3

As a reminder ....

A?smooth manifold?is a topological space that locally resembles Euclidean space and allows for smooth (infinitely differentiable) transitions between local coordinate systems. This structure allows for the use of calculus on the manifold.?

The?tangent space?at a point on a manifold is the set of tangent vectors at that point, like a line tangent to a circle or a plane tangent to a surface.

Tangent vectors?can act as directional derivatives, where you can apply specific formulas to characterize these derivatives.

A Lie algebra is a vector space g and a bilinear operator known as Lie bracket or?Lie commutator defined as:

with the properties

1. Anticommutative:? ??[X,Y] = -[Y, X]
2. Jacobi Identity:?????? [[X,Y], Z] + [[Y,Z],X] + [[Z,X],Y] = 0

?

Examples

Let's consider the n-dimension General Linear Group on complex numbers?GL(n, C) of n x n invertible matrices. The Lie algebra is defined as

The?Special Orthogonal Group?in 3 dimensions,?SO(3)?is the group of all rotation matrices in 3 spatial dimensions.

The Lie bracket for the SO3 group is defined as the matrix commutator of two vectors?X, Y on base point P. [X,Y] = X.Y-Y.X with the basis elements:

Implementation

Setup

Geomstats?is a free, open-source Python library designed for conducting machine learning on data situated on nonlinear manifolds, an area known as Geometric Learning. This library offers object-oriented, thoroughly unit-tested features for fundamental manifolds, operations, and learning algorithms, compatible with various execution environments, including?NumPy,?PyTorch, and?TensorFlow?(Overview Geomstats library ).

We leverage the class?LieSO3Group?defined in the previous article (?Operations on SO3 Lie Groups in Python - Implementation ).

import geomstats.backend as gs
from geomstats.geometry.special_orthogonal import SpecialOrthogonal


class LieSO3Group(object):
    dim = 3
    # Lie group as defined in Geomstats library
    lie_group =  SpecialOrthogonal(n=dim, point_type='vector', equip=False)
    identity = gs.eye(dim)

    def __init__(self, tgt_vector: np.array, base_point: np.array = identity) -> None:
        self.tangent_vec = gs.array(tgt_vector)

        # Exp. a left-invariant vector field from a base point
        self.group_element = LieSO3Group.lie_group.exp(
                self.tangent_vec, 
                base_point)
        self.base_point = base_point

  
   @classmethod
    def build(cls, tgt_vector: List[float], base_point: List[float] = None) -> 
        np_input = np.reshape(tgt_vector, (3, 3))

        np_point = np.reshape(base_point, (3, 3)) if base_point is not None 
                         else LieSO3Group.identity
        return cls(tgt_vector=np_input, base_point=np.array(base_point))        

The Lie algebra for the Special Orthogonal Group SO3 for a given tangent vector and base point is implemented through the logarithmic map in the method?lie_algebra?using the?SpecialOrthogonal.log?method in Geomstats.

   def lie_algebra(self) -> np.array:
        return LieSO3Group.lie_group.log(self.group_point, self.base_point)        

The algebra matrix is computed from a given tangent vector for a +90 degrees rotation along X-axis (3 x 3 rotation matrix) of and a given base point in the SO3 manifold.

# First SO3 rotation matrix 90 degree along x axis
so3_tangent_vec = [1.0, 0.0, 0.0, 0.0, 0.0, -1.0, 0.0, 1.0, 0.0]

# Base point is SO3 rotation matrix 90 degree along y axis
base_point = [0.0, 0.0, 1.0, 0.0, 1.0, 0.0, -1.0, 0.0, 0.0]

so3_group = LieSO3Group.build(
    tgt_vector=so3_tangent_vec, 
    base_point=base_point
print(so3_group)

lie_algebra = so3_group.lie_algebra()
assert np.array_equal(so3_group.tangent_vec, lie_algebra)

print(f'\nLie algebra:\n{lie_algebra}')        

As expected the Lie algebra of the Lie group point is identical to the original tangent vector.

Tangent vector:

[[ 1. ?0. ?0.][ 0. ?0. -1.][ 0. ?1. ?0.]]

Lie group point:

[[ 0.99 ?0.00 ?0.93][ 0.00 ?0.93 -0.99] [-0.93 ?0.99 -0.00]]

Lie algebra:

[[ 1.00 ?0.00 ? 0.00][ 0.00 ?0.00 -1.00][ 0.00 ?1.00 ?0.00]]

Projector operator

The Lie group projection operator approach is an iterative scheme usually applied to continuous-time optimal control problems on Lie groups. It is mentioned here for reference.

def projection(self) -> Self:
   projected = LieSO3Group.lie_group.projection(self.group_point)
   return LieSO3Group(projected)        

We use the same tangent vector and base point on SO3 manifold to compute the projected matrix.

# First SO3 rotation matrix 90 degree along x axis
 so3_tangent_vec = [1.0, 0.0, 0.0, 0.0, 0.0, -1.0, 0.0, 1.0, 0.0]

so3_group = LieSO3Group.build(tgt_vector=so3_tangent_vec,          
                                                         base_point=LieSO3Group.identity)

projected = so3_group.projection()
print(f'\nProjected point with identity:\n{projected.group_point}')

# Base point is SO3 rotation matrix 90 degree along y axis
base_point = [0.0, 0.0, 1.0, 0.0, 1.0, 0.0, -1.0, 0.0, 0.0]

so3_group = LieSO3Group.build(tgt_vector=so3_tangent_vec, 
                                                         base_point=base_point)
projected = so3_group.projection()
print(f'\nProjected point with\n{so3_group.tangent_vec}\n{projected.group_point}')        

Projected point with identity:

[[ 2.00 ? 0.00 ? 0.00][ 0.00 ? 1.63 ?-0.77][ 0.00 ? 0.77 ? 1.63]]

Projected point with base point [[ 1. ?0. ?0.][ 0. ?0. -1.][ 0. ?1. ?0.]]:

[[ 1.66 ? 0.35 ?0.66][ 0.35 ? 1.57 -0.74][-0.66 ? 0.74 ?1.25]]

Lie Bracket

Finally, we compute the bracket for this tangent vector,?self.tangent?with another vector,?other_tgt_vector.

def bracket(self,  other_tgt_vector: List[float]) -> np.array:
     np_vector = np.reshape(other_tgt_vector, (3, 3))
     return np.dot(self.tangent.vec, np_vector) - np.dot(np_vector, self.tangent_vec)        

Let first try to compute the bracket of a SO3 point (skew matrix) with itself.

# First SO3 rotation matrix 90 degree along x axis
so3_tangent_vec = [1.0, 0.0, 0.0, 0.0, 0.0, -1.0, 0.0, 1.0, 0.0]

so3_group = LieSO3Group.build(so3_tangent_vec)

 np.set_printoptions(precision=3)
 print(f'\nSO3 point\n{so3_groupA.group_element}')

 bracket = so3_groupA.bracket(so3_tangent_vec)
 print(f'\nBracket [x,x]:\n{bracket}')        

Tangent vector:

[[ 1. ?0. ?0.][ 0. ?0. -1.][ 0. ?1. ?0.]]

SO3 point X

[[ 2.00 ?0.00 ? 0.00][ 0.00 ?0.93 ?-0.99][ 0.00 ?0.99 ? 0.93 ]]

Bracket [X, X]:

[[0. 0. 0.][0. 0. 0.][0. 0. 0.]]

Now Let's compute the Lie bracket of two tangent vectors, one for SO3 90 degrees rotation along X axis and the other along Y axis.

# First SO3 rotation matrix 90 degree along x axis.  X
so3_tangent_vecA = [1.0, 0.0, 0.0, 0.0, 0.0, -1.0, 0.0, 1.0, 0.0]
so3_groupA = LieSO3Group.build(so3_tangent_vecA)


# Second SO3 rotation matrix 90 degree along y axis,  Y
other_tgt_vec = [0.0, 0.0, 1.0, 0.0, 1.0, 0.0, -1.0, 0.0, 0.0]

bracket = so3_groupA.bracket(other_tgt_vec)
print(f'\nBracket:\n{bracket}')        

Bracket [X, Y]:

[[ 0. -1. ? 1.][ 1. ?0. ?-1.][ -1. 1. ? 0.]]

References

[1]?Operations on SO3 Lie groups

[2]?Foundation of Geometric Learning

[3]?Differentiable Manifolds for Geometric Learning

[4]?Intrinsic Representation in Geometric Learning

[5]?Riemann Metric and Connection

[6]?Introduction to Geometric Learning in Python with Geomstats

[7]?Lie algebra - Quantum Tinkering - Omar A. Ashour

----------------------------------

Patrick Nicolas has over 25 years of experience in software and data engineering, architecture design and end-to-end deployment and support with extensive knowledge in machine learning.? He has been director of data engineering at Aideo Technologies since 2017 and he is the?author of "Scala for Machine Learning", Packt Publishing ISBN 978-1-78712-238-3 and?Geometric Learning in Python ?Newsletter on LinkedIn.