Rodrigues' Formula

Rodrigues’ formula is the closed-form expression for the matrix exponential , converting an axis–angle pair into a rotation matrix . It collapses the infinite Taylor series into a finite expression by exploiting the fact that powers of a skew-symmetric matrix cycle with period 2 through and .

Given a unit rotation axis with and angle , the rotation matrix is:

where is the skew-symmetric cross-product matrix:

For non-unit :

This is the 3D matrix analogue of Euler’s formula , where the role of (with ) is played by (with ).

Intuition

The formula decomposes the rotation of a point about axis by angle into three geometric contributions:

TermWhat it does
Keeps the original point
Swings perpendicular to both and — the “sine” component of circular motion
Pulls toward the rotation axis — the “versine” radial correction

Together, the and terms trace out a circle in the plane perpendicular to , exactly as and parameterize the unit circle in 2D.

The reason this works is that higher powers of don’t produce new directions — they cycle back through and . So the infinite series naturally groups into the Taylor series for and .

Properties

Power identities for (Lemma A)

These two identities are the engine behind the proof. For any :

  1. , from the triple cross product .

  2. , since kills the term, leaving .

When these simplify to and , producing the cycling:

Hat conjugation identity

To find the skew-symmetric matrix of a rotated vector, conjugate the original by . This is used to prove rotation matrices are orientation-preserving RBTs, and it recurs throughout Forward Kinematics and the Spatial Jacobian.

Special cases

InputOutput
(no rotation)
(180° flip)
(full revolution)
, any Recovers the standard 2D rotation matrix

Proof sketch

Expand , substitute the cycling pattern from Lemma A, and group terms:

Examples

Rotation about -axis by

Let . Then and .

This recovers the standard , confirming that elemental rotations used in Euler Angles are special cases of Rodrigues’.

180° about an arbitrary axis

With : and , so:

This rank-1 structure () is exactly what the Exponential Coordinates log map exploits in Case 3 () to recover by normalizing any nonzero column of .

Implementation

import numpy as np
 
def skew(w):
    return np.array([[0, -w[2], w[1]], [w[2], 0, -w[0]], [-w[1], w[0], 0]])
 
def rodrigues(omega, theta):
    """omega: unit vector (3,), theta: angle in radians -> R in SO(3)"""
    w_hat = skew(omega)
    return np.eye(3) + w_hat * np.sin(theta) + w_hat @ w_hat * (1 - np.cos(theta))

The inverse operation — recovering from — is the log map, covered in Exponential Coordinates.