Lie Groups: SO(3) and SE(3) — Math Reference

1. At a glance

Rotations and rigid-body transformations are the bread-and-butter of robotics, computer vision, graphics, and classical/quantum physics. They are not vector spaces: you cannot add two rotation matrices and get a rotation matrix, and you cannot linearly interpolate poses without breaking orthogonality. Yet they have rich structure — they are smooth manifolds that also carry a group operation (composition), with the group operation and its inverse being smooth maps. Spaces of this kind are called Lie groups (Sophus Lie, 1880s).

Lie theory gives us:

• A tangent space at the identity, called the Lie algebra, which is a vector space — so we can do calculus, take gradients, and run optimizers there.
• An exponential map that turns a tangent vector into a group element (integrates an infinitesimal motion into a finite one).
• A logarithm map for the inverse direction.
• Adjoint representations for converting between body-frame and world-frame quantities.
• Baker-Campbell-Hausdorff (BCH) formulas for composing motions inside the Lie algebra without leaving it.

Why every robotics, vision, and physics engineer ends up here:

• Robotics: forward/inverse kinematics, SLAM back-ends, IMU preintegration, manipulator Jacobians.
• Computer vision: camera pose (PnP), structure-from-motion, visual-inertial odometry.
• Graphics: character animation, skinning, camera paths, physically based simulation.
• Physics: rigid-body dynamics, spacecraft attitude control, gauge field theory.
• Quantum: SU(2) for spin-1/2, SU(3) for chromodynamics — the same machinery, different group.

The two stars of this note are SO(3) (3D rotations) and SE(3) (3D rigid-body motions = rotations + translations). Together they cover virtually every “pose” you will ever need to represent or optimize over.

---

2. SO(3) — the rotation group in 3D

Definition. SO(3) is the set of 3×3 real matrices R satisfying

• R^TR = R R^T = I (orthogonality), and
• det R = +1 (orientation-preserving — excludes reflections, which live in O(3)).

Degrees of freedom. Nine entries minus six constraints (three diagonal “unit-length” + three off-diagonal “orthogonality”) = 3 DoF. This matches the intuitive count: yaw, pitch, roll.

Manifold structure. SO(3) is a 3-dimensional smooth manifold embedded in ℝ⁹. Topologically it is the real projective space ℝP³, which is compact, connected, and not simply connected (its universal cover is the 3-sphere S³, which corresponds to unit quaternions — see §12).

Group operation.

• Composition: R₁ · R₂ (matrix product); not commutative.
• Identity: 3×3 identity matrix I.
• Inverse: R⁻¹ = R^T (orthogonality).

Action on ℝ³. A vector v ∈ ℝ³ rotates as v’ = R v.

---

3. Tangent space and Lie algebra so(3)

Tangent at identity. Differentiate R(t)^TR(t) = I at t = 0:

Ṙ(0)^T + Ṙ(0) = 0 ⇒ Ṙ(0) is skew-symmetric.

So the tangent space at the identity is the set of 3×3 skew-symmetric matrices, denoted so(3) (lowercase Fraktur).

Hat operator. Each skew-symmetric matrix is determined by 3 scalars, packaged as ω = (ω_x, ω_y, ω_z) ∈ ℝ³:

[ω]_× = ω̂ = ⎡ 0 −ω_z ω_y ⎤ ⎢ ω_z 0 −ω_x ⎥ ⎣ −ω_y ω_x 0 ⎦

The hat operator is an isomorphism so(3) ≅ ℝ³. The vee operator (∨) inverts it: ([ω]_×)^∨ = ω.

Physical meaning. ω is the angular velocity vector. For a rigid body with orientation R(t),

Ṙ = R · [ω_body]_× = [ω_space]_× · R,

where ω_body is angular velocity in the body frame and ω_space = R ω_body in the world frame.

Lie bracket. so(3) is a Lie algebra with bracket [A, B] = AB − BA. For skew matrices this corresponds to the cross product on ℝ³:

[[a]_×, [b]_×] = [a × b]_×.

Useful identities.

• [u]_× v = u × v.
• [u]_ײ = u u^T − ‖u‖² I (rank-2, projection-like).
• [u]_׳ = −‖u‖² [u]_× (when ‖u‖ = 1: [u]_׳ = −[u]_×).

---

4. Exponential map: so(3) → SO(3)

The matrix exponential

exp(A) = Σ_k=0..∞ A^k / k!

maps so(3) into SO(3). For a skew matrix [ω]_× with ω = θ u, ‖u‖ = 1, the series collapses to the Rodrigues rotation formula (Olinde Rodrigues, 1840):

R = exp([ω]_×) = I + sin θ · [u]_× + (1 − cos θ) · [u]_ײ.

Derivation sketch. Using [u]_׳ = −[u]_× (for unit u), every higher power reduces to [u]_× or [u]_ײ, and the series factors into sin θ and (1 − cos θ).

Numerical stability near θ = 0. Use the Taylor expansions

sin θ / θ ≈ 1 − θ²/6 + θ⁴/120, (1 − cos θ) / θ² ≈ ½ − θ²/24 + θ⁴/720,

and write Rodrigues as

R = I + (sin θ / θ) · [ω]_× + ((1 − cos θ) / θ²) · [ω]_ײ,

which is well-defined for any θ including 0.

Surjectivity. exp: so(3) → SO(3) is surjective but not injective (rotations by θ and θ + 2π give the same R). It is a diffeomorphism on the open ball ‖ω‖ < π.

---

5. Logarithm map: SO(3) → so(3)

Given R ∈ SO(3) with R ≠ I, recover ω:

θ = arccos((tr R − 1) / 2), [u]_× = (R − R^T) / (2 sin θ), ω = θ u.

Edge cases.

• R = I (θ = 0): ω = 0.
• θ near π (tr R ≈ −1): sin θ → 0, the simple formula above is ill-conditioned. Use the diagonal of R + I to extract u (largest diagonal element gives the most stable axis).
• General: clip (tr R − 1) / 2 to [−1, 1] before arccos to guard floating-point overflow.

The pair (exp, log) lets you treat a rotation either as a 3×3 matrix (for composition / acting on vectors) or as a 3-vector ω in so(3) (for optimization / interpolation / integration).

---

6. Right + left actions, adjoint

A Lie group acts on itself by left translation L_g(h) = g h and right translation R_g(h) = h g. Differentiating conjugation g h g⁻¹ at the identity gives the adjoint representation:

Ad: G → GL(g), Ad(g)(X) = g X g⁻¹ for X in the Lie algebra.

For SO(3). Ad(R) ω = R ω — the adjoint is just the rotation matrix acting on the vector ω. This is what converts angular velocity expressed in the body frame to the spatial (world) frame:

ω_space = Ad(R) · ω_body = R · ω_body.

Adjoint of the algebra (lowercase ad). ad_X(Y) = [X, Y]. For SO(3), ad_ω̂ v̂ = (ω × v)̂, i.e., ad is the cross product.

---

7. SE(3) — rigid-body transformations in 3D

Definition. SE(3) is the special Euclidean group: pairs (R, t) with R ∈ SO(3), t ∈ ℝ³. Represented as 4×4 homogeneous matrices:

T = ⎡ R t ⎤ ⎣ 0 1 ⎦.

Degrees of freedom. 3 (rotation) + 3 (translation) = 6 DoF.

Group operation. Matrix product:

T₁ T₂ = ⎡ R₁ R₂ R₁ t₂ + t₁ ⎤ ⎣ 0 1 ⎦.

Inverse.

T⁻¹ = ⎡ R^T −R^T t ⎤ ⎣ 0 1 ⎦.

Action on points. A homogeneous point [p; 1] ∈ ℝ⁴ transforms as

[p’; 1] = T [p; 1] = [R p + t; 1].

Topology. SE(3) ≅ SO(3) × ℝ³ as a manifold (3 + 3 = 6 dimensions), but the group operation is a semidirect product — translations and rotations don’t commute.

---

8. Lie algebra se(3) — twists

The tangent space at the identity, se(3), consists of 4×4 matrices

ξ̂ = ⎡ ω̂ v ⎤ ⎣ 0 0 ⎦,

parameterized by ξ = (v, ω) ∈ ℝ⁶ — the linear velocity v ∈ ℝ³ and angular velocity ω ∈ ℝ³. (Some authors use the order (ω, v); always check conventions.)

Lie bracket. [ξ̂₁, ξ̂₂] = ξ̂₁ ξ̂₂ − ξ̂₂ ξ̂₁, which in 6-vector form is

[ξ₁, ξ₂] = ⎛ ω₁ × v₂ + v₁ × ω₂ ⎞ ⎝ ω₁ × ω₂ ⎠.

A vector in se(3) is called a twist — combined linear and angular velocity of a screw motion.

---

9. Exponential map for SE(3) — screw motions

For ξ = (v, ω) ∈ ℝ⁶ with ω = θ u, ‖u‖ = 1, the closed form is

exp(ξ̂) = ⎡ exp([ω]_×) V(θ) v ⎤ ⎣ 0 1 ⎦,

where exp([ω]_×) is Rodrigues (§4) and the left Jacobian of SO(3) is

V(θ) = I + ((1 − cos θ) / θ²) [u·θ]_× + ((θ − sin θ) / θ³) [u·θ]_ײ = I + ((1 − cos θ) / θ) [u]_× + ((θ − sin θ) / θ) [u]_ײ.

Mozzi-Chasles theorem (Mozzi 1763, Chasles 1830). Every rigid-body displacement in 3D is equivalent to a rotation about a unique axis (the screw axis) combined with a translation along that axis. The exp(ξ̂) formula realizes this: ω gives the axis direction, the magnitude θ = ‖ω‖ is the rotation, and the v component along ω is the pitch (translation per radian).

Pure translation case (ω = 0). The formula degenerates gracefully:

exp(ξ̂) = ⎡ I v ⎤ ⎣ 0 1 ⎦,

i.e., V(0) = I.

Numerical guards. Like Rodrigues, use the Taylor series of (1 − cos θ)/θ² and (θ − sin θ)/θ³ for small θ.

---

10. Adjoint of SE(3)

The 6×6 adjoint matrix converts twists between frames:

Ad(T) = ⎡ R [t]_× R ⎤ ⎣ 0 R ⎦.

A twist ξ in body frame transforms to spatial frame via ξ_spatial = Ad(T) ξ_body.

Properties.

• Ad(T₁ T₂) = Ad(T₁) Ad(T₂).
• Ad(T⁻¹) = Ad(T)⁻¹.
• Ad(I) = I_6×6.

Differential adjoint.

ad(ξ) = ⎡ [ω]_× [v]_× ⎤ ⎣ 0 [ω]_× ⎦,

so that ad(ξ₁) ξ₂ = [ξ₁, ξ₂].

---

11. Baker-Campbell-Hausdorff (BCH)

For two Lie algebra elements X, Y, the product of exponentials is not the exponential of the sum — the group is non-commutative. BCH gives the series:

log(exp(X) · exp(Y)) = X + Y + ½[X, Y] + (1/12)([X, [X, Y]] + [Y, [Y, X]]) + …

First-order BCH (small X, Y): log(exp(X) exp(Y)) ≈ X + Y. Used in IMU integration when individual increments are small.

Second-order BCH: log(exp(X) exp(Y)) ≈ X + Y + ½[X, Y]. The half-bracket term is the leading correction for non-commutativity — exactly the source of “the order of rotations matters.”

Applications.

• Composing many small rotations/translations in a SLAM or IMU pipeline without leaving the manifold.
• Closed-form formulas for left/right Jacobians (see §15).
• Preintegration of IMU measurements over a window (Forster et al. 2015 RSS).

---

12. Quaternions — the alternative to rotation matrices

A quaternion q ∈ ℍ is a 4-tuple (w, x, y, z) with multiplication defined by Hamilton’s relations i² = j² = k² = ijk = −1.

A unit quaternion ‖q‖ = 1 represents a rotation. If the rotation is angle θ about unit axis u,

q = (cos(θ/2), u_x sin(θ/2), u_y sin(θ/2), u_z sin(θ/2)).

Double cover. Unit quaternions form the 3-sphere S³, which is a 2-to-1 cover of SO(3): q and −q correspond to the same rotation. S³ is simply connected; SO(3) is not.

DoF accounting. 4 entries − 1 norm constraint = 3 DoF — same as SO(3), but with only a single scalar constraint to maintain (vs. 6 for a rotation matrix), making renormalization much cheaper and more numerically stable.

Composition. Hamilton product q₁ ⊗ q₂ corresponds to composition of rotations R₁ R₂. Sixteen multiplications + 12 adds — cheaper than the 27 mul + 18 add of a 3×3 matrix product.

Rotating a vector. Treating v ∈ ℝ³ as a pure imaginary quaternion (0, v),

v’ = q ⊗ v ⊗ q⁻¹ = q ⊗ v ⊗ q*,

where q* = (w, −x, −y, −z) is the conjugate (equal to inverse for unit q).

SLERP — Spherical Linear Interpolation (Ken Shoemake, SIGGRAPH 1985):

slerp(q₀, q₁, t) = (sin((1 − t) Ω) / sin Ω) q₀ + (sin(t Ω) / sin Ω) q₁,

where Ω = arccos(q₀ · q₁). Produces constant angular velocity interpolation along the great circle on S³. For Ω small, fall back to linear interpolation + renormalization (NLERP) to avoid division by sin Ω → 0.

Numerical advantages over matrices.

• One scalar normalization vs. six orthogonality constraints.
• No matrix-square-root drift in long integrations.
• Compact storage (16 bytes float32 vs. 36 bytes).

Where they are used.

• Aerospace IMU and attitude determination (e.g., spacecraft AOCS).
• 3D animation in games and film (Maya, Blender, Unity, Unreal).
• AR/VR pose tracking (Apple ARKit, Google ARCore, Meta).
• Robotics middleware (ROS tf2, MoveIt).
• Mobile robot orientation estimation (Madgwick, Mahony filters).

---

13. Other rotation parameterizations

Parameterization	Params	Constraints	DoF	Pitfalls
Rotation matrix R	9	6 (orthogonality)	3	Drift during integration; expensive to renormalize.
Unit quaternion q	4	1 (‖q‖ = 1)	3	Double cover (q ≡ −q); requires choosing a sign convention for interpolation.
Axis-angle (u, θ)	4	1 (‖u‖ = 1)	3	Singular at θ = 0 (u undefined); discontinuous at θ = π.
Rotation vector ω = θ u	3	0	3	Equals the so(3) representation; singular at θ = π (no unique log).
Euler angles (ZYX, etc.)	3	0	3	Gimbal lock; 24 different conventions; non-unique near singularities.
Modified Rodrigues parameters (MRP)	3	0	3	Singular at θ = 2π; “shadow set” trick to switch parameterizations.
Cayley parameters	3	0	3	Singular at θ = π; rational map (no transcendentals).

Practical rule. For storage and composition: quaternions. For optimization and propagation: the Lie algebra (rotation vector). For display to humans: Euler angles (but never trust them for math). For acting on vectors: convert to a rotation matrix on demand.

---

14. Manifold optimization

Standard gradient descent assumes a vector space. On SO(3) and SE(3), the variables live on a curved manifold, so you can’t just do x ← x − η ∇f(x) — adding a tangent vector to a manifold point doesn’t return a manifold point in general. The remedy:

Retraction. A smooth map R_p: T_pM → M that locally agrees with the exponential map to first order. For SO(3) and SE(3), the natural choice is the exponential map itself; cheaper alternatives include the Cayley map and the polar-decomposition retraction (project a perturbed matrix back to SO(3) via SVD or QR).

Vector transport. When comparing tangent vectors at different base points (e.g., conjugate gradient with momentum), parallel-transport them along the connecting geodesic. For SO(3) the simplest transport is the adjoint action.

Riemannian gradient and Hessian. The Riemannian gradient is the orthogonal projection of the Euclidean gradient onto the tangent space; the Riemannian Hessian additionally accounts for the curvature (Levi-Civita connection).

Trust-region and line-search on manifolds. Replace x + αd with R<sub>x</sub>(αd). Convergence theory carries over (Absil, Mahony, Sepulchre 2008 “Optimization Algorithms on Matrix Manifolds”).

Libraries.

• Manopt (MATLAB, Boumal et al.) — the original.
• Pymanopt (Python) — same algorithms, NumPy/Autograd/JAX backends.
• ROPTLIB (C++) — research code.
• manif (Deray, Sola; C++/Python) — micro Lie theory for robotics.
• Sophus (Strasdat 2012) — header-only C++; SO(3), SE(3), Sim(3); de facto standard in visual SLAM (used by ORB-SLAM, DSO, LSD-SLAM).
• GTSAM Pose3, Ceres Manifold — factor-graph and nonlinear least-squares with manifold support.

---

15. Lie group calculus — Jacobians and perturbation conventions

To linearize a function f: G → ℝⁿ, you need a notion of derivative on the manifold. Two conventions are common; both involve a Jacobian relating perturbations in the Lie algebra to perturbations of the output.

Right perturbation (robotics standard, used by Sophus, GTSAM, manif):

f(T · exp(δξ̂)) ≈ f(T) + J_r δξ.

Left perturbation (more common in physics and some vision texts):

f(exp(δξ̂) · T) ≈ f(T) + J_l δξ.

The two are related by J_l = J_r Ad(T⁻¹).

Right and left Jacobians of SO(3). For ω = θ u, ‖u‖ = 1:

J_r(ω) = I − ((1 − cos θ) / θ²) [ω]_× + ((θ − sin θ) / θ³) [ω]_ײ, J_l(ω) = I + ((1 − cos θ) / θ²) [ω]_× + ((θ − sin θ) / θ³) [ω]_ײ = V(θ) from §9.

Note J_l(ω) = J_r(−ω).

Inverse Jacobian.

J_r⁻¹(ω) = I + ½ [ω]_× + (1/θ² − (1 + cos θ) / (2 θ sin θ)) [ω]_ײ.

These appear in Gauss-Newton updates on SO(3)/SE(3) (Sola et al. 2018 “A Micro Lie Theory for State Estimation in Robotics” is the cleanest reference).

Worked example — pose error. Given two poses T₁, T₂, the residual ξ = log(T₁⁻¹ T₂) is a twist; its Jacobians with respect to right-perturbations of T₁ and T₂ are −J_r(ξ)⁻¹ Ad(T₂⁻¹ T₁) and J_r(ξ)⁻¹ respectively. These are the closed-form analytical Jacobians a SLAM optimizer like g2o, GTSAM, or Ceres expects.

---

16. SLAM and factor graphs

In modern SLAM, the world state is a set of robot poses (SE(3)) and possibly landmarks (ℝ³ or SE(3) for object pose). Measurements (odometry, loop closures, visual landmark observations) are encoded as factors connecting variables in a bipartite factor graph (Dellaert + Kaess 2017 “Factor Graphs for Robot Perception”).

• Variables: nodes are pose_i ∈ SE(3), landmark_j ∈ ℝ³.
• Factors: edges encode a measurement likelihood, e.g., relative-pose factor ‖log(z_ij⁻¹ T_i⁻¹ T_j)‖_Σ².
• Optimization: Gauss-Newton / Levenberg-Marquardt iterations on the manifold; updates are computed in the tangent space, then retracted via the SE(3) exp map.

Production implementations: GTSAM (Frank Dellaert, Georgia Tech), g2o (Kümmerle et al.), Ceres Solver with Manifold plugin (Google), iSAM2 (incremental smoothing), and TORO, HOG-Man (older). All speak the SE(3) Lie-group language internally.

---

17. Continuous-time integration on Lie groups

Given angular velocity ω(t), the rotation matrix evolves as

Ṙ = R · [ω]_× (body-frame convention)

or Ṙ = [ω]_× · R for spatial-frame ω. The naive Euler step R(t + Δt) ← R(t) + Δt · R(t) · [ω]_× destroys orthogonality after a few steps.

Lie-group integrators preserve the manifold by construction.

• Matrix exponential update: R(t + Δt) = R(t) · exp(Δt · [ω]_×). Exact for constant ω; cheap with Rodrigues.
• Munthe-Kaas methods (Munthe-Kaas 1998): adapt classical Runge-Kutta to act in the Lie algebra (sum-of-tangents) and retract at the end via exp.
• Crouch-Grossman methods (Crouch + Grossman 1993): a different splitting tailored to Lie groups; same-order accuracy as RK but stays on the manifold.
• Lie-Trotter / Strang splitting: alternate sub-steps for translation and rotation, useful in rigid-body dynamics.
• Quaternion integration with renormalization: simpler when storage is the quaternion; renormalize every step or every few steps.

Rule of thumb in simulation. For high-fidelity rigid-body simulators (Bullet, MuJoCo, Drake, PhysX, Brax), the integrator is some flavor of Lie-group RK + projection/renormalization. For real-time games, quaternion + first-order Euler + renormalize is usually good enough at 60–240 Hz.

---

18. Other Lie groups in engineering

Group	Dimension	Where you meet it
SO(2)	1	Planar rotation (compass bearing, 2D image rotation).
SE(2)	3	Planar rigid bodies — mobile robots, 2D SLAM (TurtleBot, AGVs).
SO(3)	3	3D rotation (this note).
SE(3)	6	3D rigid body (this note).
Sim(3)	7	Similarity = SE(3) + uniform scale; monocular visual SLAM uses it to resolve scale drift in loop closures (Strasdat 2010).
SL(n)	n² − 1	Special linear group; SL(3) = projective transforms used in homographies (planar AR, image stitching).
GL(n)	n²	General linear group; not compact; rarely a target manifold but the ambient space of matrices.
Aff(n)	n² + n	Affine transforms = GL(n) ⋉ ℝn.
SE(2) ⋉ ℝ	4	”Pose + heading-velocity” used in some planar-vehicle estimators.
SO(n)	n(n−1)/2	Higher-dimensional rotations (e.g., 4D rotations in physics simulations, manifold learning).
U(n), SU(n)	n², n² − 1	Complex unitary groups: SU(2) for spin-1/2 (double cover of SO(3)); SU(3) for QCD; U(1) for electromagnetism.
Sp(2n, ℝ)	n(2n+1)	Symplectic group — phase-space transformations in Hamiltonian mechanics.

The same exp/log/adjoint/BCH machinery works for all of them once you write down the appropriate Lie algebra and bracket.

---

19. Applications — where this math earns its keep

Robotics.

• Forward kinematics of a serial manipulator: chain of SE(3) transforms, T_end = T₀ · exp(θ₁ ξ̂₁) · … · exp(θ_n ξ̂_n) (product of exponentials, Brockett 1984).
• Inverse kinematics via Levenberg-Marquardt on SE(3) error; the manipulator Jacobian J_geom ∈ ℝ^6×n relates joint velocities to end-effector twists.
• Manipulability ellipsoid = JJ^T in SE(3) twist space; singular values reveal directions where the arm is near singular (Yoshikawa 1985).
• Motion planning in SE(3) (RRT*, PRM) requires a metric and an interpolant — typically a weighted combination of geodesic distance on SO(3) and Euclidean on ℝ³.

SLAM and odometry.

• Pose-graph optimization (g2o, GTSAM, Ceres) — nonlinear least squares on SE(3)^N.
• Visual-inertial odometry — state lives on TS × SE(3) (pose + velocity + IMU biases) with manifold updates.
• IMU preintegration (Forster, Carlone, Dellaert, Scaramuzza 2015 RSS) — preintegrate IMU measurements into a single SE(3)-valued factor using BCH and the SO(3) Jacobians; used in VINS-Mono, ORB-SLAM3, Kimera, OpenVINS.
• Loop closure with Sim(3) in monocular SLAM — resolves the scale ambiguity that pure SE(3) cannot.

Computer vision.

• Perspective-n-Point (PnP) — recover camera pose ∈ SE(3) from 2D-3D correspondences; nonlinear refinement uses SE(3) exp/log.
• Structure-from-motion — bundle adjustment over thousands of camera poses in SE(3) and 3D points (COLMAP, Theia, OpenMVG).
• Multi-view geometry — essential matrix factorizes into SE(3) up to scale.

Animation and graphics.

• Skeletal animation — bones are SE(3); skinning blends multiple SE(3) transforms via linear blend skinning (LBS) or dual-quaternion skinning (Kavan et al. 2007), which avoids LBS’s candy-wrapper artifact.
• Camera paths — interpolate keyframe SE(3) poses with SLERP/Bezier on the manifold.
• Physically based rigid-body simulation — Featherstone’s articulated-body algorithm on SE(3).

Aerospace and control.

• Spacecraft attitude control with quaternion feedback laws (Wie, Wertz); avoids gimbal lock and double-cover handled by sign-flip on q.
• Quadrotor geometric control on SE(3) (Lee, Leok, McClamroch 2010) — avoids Euler-angle singularities for aggressive maneuvers.
• AUV / UAV navigation — Kalman filters on Lie groups (Bonnabel + Barrau 2017 “Invariant Extended Kalman Filter” — IEKF — exploits SE(3) structure for guaranteed convergence properties).

Physics and other sciences.

• Hamiltonian mechanics on Lie groups (Marsden + Ratiu).
• Gauge theory — connections on principal bundles with structure group SU(n), SO(n).
• Robotics + games — differential games and control on manifolds (pursuit-evasion, multi-agent coordination).

---

20. Pitfalls

• Adding rotation matrices. R₁ + R₂ is not in SO(3). To “average” or blend, go to the Lie algebra (log → average ω → exp), use SLERP on quaternions, or use the projection (R₁ + R₂) followed by SVD-based polar decomposition.
• Quaternion sign ambiguity. Always keep the dot product q_k · q_k+1 ≥ 0 when integrating or interpolating; flip the sign of one quaternion if not, to walk the short way around S³.
• Euler-angle gimbal lock. Near β = ±π/2 in a ZYX Euler convention, the first and third axes align and you lose 1 DoF in the parameterization. Symptom: huge angle wraps near singularities. Cure: don’t use Euler internally; only display them.
• Mixing left vs. right perturbation. Sophus, GTSAM, Ceres use right-perturbation T · exp(δξ̂). Some physics texts and the older robotics literature (Murray, Li, Sastry 1994) use left. Mixing them silently produces wrong Jacobians and slow / divergent optimizations.
• Treating 3×3 rotation entries as 9 independent variables. A non-manifold optimizer will happily wander out of SO(3). Either constrain to the manifold (Lagrange multipliers / projection) or parameterize by ω ∈ so(3) or q ∈ S³.
• Numerical stability near θ = 0. The naive Rodrigues formula has sin θ / θ and (1 − cos θ) / θ² — both 0/0 at θ = 0. Always use the Taylor expansions for θ below ~1e-4 (depends on float precision).
• Logarithm at θ = π. sin θ → 0 in the denominator of the simple log formula. Use the diagonal-of-R + I trick to extract the axis at the antipode.
• Composing many small motions naively. First-order Euler integration drifts off SO(3) after a few thousand steps. Use exp-update, renormalization, or a Lie-group integrator (§17).
• Forgetting Ad(T) when changing frames. ω_body and ω_spatial differ by R; twists between frames differ by Ad(T). Missing the adjoint is the #1 source of “my IK / Jacobian is wrong by a rotation.”

---

21. Cross-references

• linear-algebra-essentials — vector spaces, matrix products, orthogonal decompositions underpinning everything here.
• svd-pca-spectral — polar decomposition / SVD used to project a near-rotation matrix back to SO(3).
• numerical-linear-algebra — stable matrix exponential, Schur, polar decomposition.
• ode-numerical-methods — Runge-Kutta and friends; Lie-group integrators (Munthe-Kaas, Crouch-Grossman) extend these to manifolds.
• convex-optimization — base optimization theory that manifold optimization generalizes.
• _index — overall Math index.
• kinematics-dh — Denavit-Hartenberg parameters; product-of-exponentials (POE) is the SE(3)-flavored alternative.
• dynamics-rigid-body — Newton-Euler / Featherstone on SE(3).
• slam — pose-graph SLAM, factor graphs, IMU preintegration.
• bayesian-estimation — Kalman filters and their invariant Lie-group versions (IEKF).
• spacecraft-attitude-control — quaternion feedback, geometric SO(3) control.

---

22. Citations

• Murray, R. M.; Li, Z.; Sastry, S. S. (1994). A Mathematical Introduction to Robotic Manipulation. CRC Press. The classic; introduced product-of-exponentials and screw-theoretic kinematics to a generation of roboticists.
• Lynch, K. M.; Park, F. C. (2017). Modern Robotics: Mechanics, Planning, and Control. Cambridge University Press. The current standard textbook; full SE(3) treatment with code.
• Sola, J.; Deray, J.; Atchuthan, D. (2018). A Micro Lie Theory for State Estimation in Robotics. arXiv:1812.01537. Concise, clear derivations of all the Jacobians; matches the Sophus / manif convention.
• Eade, E. (2017). Lie Groups for 2D and 3D Transformations. Online notes (ethaneade.com). Compact reference with worked formulas.
• Forster, C.; Carlone, L.; Dellaert, F.; Scaramuzza, D. (2015). IMU Preintegration on Manifold for Efficient Visual-Inertial Maximum-a-Posteriori Estimation. RSS 2015. Foundational for modern VIO.
• Strasdat, H. (2012). Local Accuracy and Global Consistency for Efficient Visual SLAM. PhD thesis, Imperial College London. Sophus library; Sim(3) for monocular SLAM.
• Shoemake, K. (1985). Animating Rotation with Quaternion Curves. SIGGRAPH 1985 Proceedings, pp. 245–254. The original SLERP paper.
• Rodrigues, O. (1840). Des lois géométriques qui régissent les déplacements d’un système solide. Journal de Mathématiques Pures et Appliquées. The Rodrigues formula.
• Mozzi, G. (1763). Discorso Matematico sopra il Rotamento Momentaneo dei Corpi. Early statement of the screw theorem; later refined by Chasles (1830).
• Brockett, R. W. (1984). Robotic Manipulators and the Product of Exponentials Formula. In Mathematical Theory of Networks and Systems. Springer. Introduced POE to robotics.
• Lee, T.; Leok, M.; McClamroch, N. H. (2010). Geometric Tracking Control of a Quadrotor UAV on SE(3). CDC 2010. Quadrotor control without Euler-angle singularities.
• Bonnabel, S.; Barrau, A. (2017). The Invariant Extended Kalman Filter as a Stable Observer. IEEE TAC. IEKF on Lie groups.
• Absil, P.-A.; Mahony, R.; Sepulchre, R. (2008). Optimization Algorithms on Matrix Manifolds. Princeton University Press. The textbook for manifold optimization.
• Dellaert, F.; Kaess, M. (2017). Factor Graphs for Robot Perception. Foundations and Trends in Robotics 6(1-2). The factor-graph view of SLAM.
• Munthe-Kaas, H. (1998). Runge-Kutta Methods on Lie Groups. BIT Numerical Mathematics 38, 92–111. Lie-group RK.
• Crouch, P. E.; Grossman, R. (1993). Numerical Integration of Ordinary Differential Equations on Manifolds. Journal of Nonlinear Science 3, 1–33.
• Kavan, L.; Collins, S.; Žára, J.; O’Sullivan, C. (2007). Skinning with Dual Quaternions. I3D 2007. Dual-quaternion skinning for animation.
• Yoshikawa, T. (1985). Manipulability of Robotic Mechanisms. IJRR 4(2), 3–9. The manipulability ellipsoid.