Product of exponentials: the Modern Robotics approach

Denavit-Hartenberg parameters are the traditional way to describe an arm's kinematics. They work, but they're fiddly — four numbers per joint, frame conventions that matter, multiple valid parameter sets for the same arm. The Product of Exponentials (PoE) formulation, popularized by Lynch and Park's Modern Robotics textbook, is cleaner. One screw axis per joint, one formula, no frame-placement rituals.

The screw axis

Every joint in a robot is a screw motion: a rotation about an axis combined with a translation along it. Revolute joints rotate, prismatic joints slide, helical joints do both. All three are screws with different pitch.

A screw axis is encoded as a 6-vector $\mathcal{S}=\left[\begin{array}{c}\omega \\ v\end{array}\right]$, where $\omega \in {\mathbb{R}}^3$ is the rotation axis direction and $v\in {\mathbb{R}}^3$ is the linear-velocity component. For a revolute joint, $\omega$ is a unit vector and $v=-\omega \times q$ where $q$ is any point on the axis.

The exponential map

The key mathematical tool: the matrix exponential turns a screw axis (times an angle) into a 4×4 homogeneous transform.

Where $\hat{\mathcal{S}}$ is the 4×4 matrix form of the 6-vector screw axis:

You don't evaluate that Taylor series at runtime — there's a closed-form (Rodrigues' formula generalized to SE(3)). scipy or any Lie-group library ships it.

The kinematics formula

Given an n-joint arm with screw axes ${\mathcal{S}}_1,{\mathcal{S}}_2,\dots ,{\mathcal{S}}_n$ (expressed in the base frame when the arm is at its home configuration $M$), the forward kinematics are:

That's it. One formula. No frame placements. No DH parameter table. To describe a robot in PoE form you need: one home-configuration pose $M$ and one screw axis per joint.

Why PoE beats DH

• Geometric, not algebraic. Each ${\mathcal{S}}_i$ is "the axis of joint i, in the base frame." That's literal. No frame placement conventions to argue about.
• No parameter-set ambiguity. DH lets you write the same robot with multiple valid parameter sets. PoE is unique (modulo choosing the home configuration).
• Modern library support. Modern Robotics ships a Python package (modern_robotics) that does PoE FK, IK, Jacobians directly from screw axes.
• Better for modern algorithms. Trajectory optimization and learning-based IK prefer the smooth Lie-group formulation of PoE over DH's angular ambiguities.

Python with modern_robotics

import numpy as np
from modern_robotics import FKinSpace

# 2-DOF planar arm, link lengths L1=L2=1, planar in xy
# Home configuration: end-effector at (L1+L2, 0, 0)
M = np.array([
    [1, 0, 0, 2.0],
    [0, 1, 0, 0.0],
    [0, 0, 1, 0.0],
    [0, 0, 0, 1.0],
])

# Joint 1: revolute about z at origin → ω=[0,0,1], v=0
# Joint 2: revolute about z at (1,0,0) → ω=[0,0,1], v=-ω×q = [0,-1,0]·(1)=[0,1,0] wait...
#   v_i = -ω × q_i; q=(1,0,0) so v = -[0,0,1]×[1,0,0] = -[0,1,0] = [0,-1,0]
Slist = np.array([
    [0, 0, 1, 0,  0, 0],   # S1 (rows = ω, v)
    [0, 0, 1, 0, -1, 0],   # S2
]).T                       # shape (6, n)

theta = np.array([np.pi/4, np.pi/4])
T = FKinSpace(M, Slist, theta)
print(T)

Four lines to describe an arm, one call to compute FK. Swap in a 6-DOF Franka or a 7-DOF Panda — the Python stays the same, only Slist and M change.

When to still use DH

• You're reading a 2015-or-earlier robotics paper. DH was universal for decades; fluency matters.
• Your robot's manufacturer ships DH parameters, not PoE.
• Converting DH → PoE is trivial (dedicated tools exist); the reverse is also doable.

In new codebases and new courses, PoE wins. Coursera's Modern Robotics specialization built its entire pedagogy around it — that's the fastest way to learn if you want the full treatment.

Next

Velocity kinematics and the Jacobian — how joint speeds connect to end-effector motion, also cleaner in PoE form.