Robot Jacobian

What the Jacobian actually does

A robot arm is commanded one way and measured another. You command motors — joint angles and joint speeds. You care about something else entirely — where the tool is and how fast it is moving in the room. The forward kinematics function answers the first half of that: feed it the joint angles q and it returns the tool pose x = f(q). But control happens in velocity, not just position, and you cannot drive a weld seam, a spray gun, or a surgical instrument along a path unless you can translate "move the tool at 0.1 m/s along this line" into "spin joint 1 at this rate, joint 2 at that rate, joint 3 at this other rate."

That translation is the Jacobian. Differentiate the forward-kinematics map with respect to time and the chain rule produces a matrix that multiplies the joint-velocity vector:

ẋ = J(q) · q̇

Here q̇ is the joint-velocity vector with one entry per actuated joint, and ẋ is the end-effector twist: a six-element stack of three linear velocities and three angular velocities, [vₓ v_y v_z ωₓ ω_y ω_z]ᵀ. The matrix J(q) therefore has six rows (one per task-space degree of freedom) and n columns (one per joint). For a standard six-axis industrial arm it is square, 6×6. For a seven-axis collaborative arm like a Franka Emika Panda or a KUKA LBR iiwa it is 6×7 — wider than it is tall, which is what makes the arm redundant.

The single most useful way to read the matrix is column by column. Column i of J is the tool twist you would see if joint i moved at unit speed and every other joint were frozen. The full tool motion is just the linear combination of those columns weighted by each joint's actual speed. That picture immediately explains everything else: if two columns point the same way, the arm has redundant directions of motion and wasted controllability; if a column collapses to zero or two columns become parallel, the arm has lost a direction entirely — a singularity.

Building the geometric Jacobian column by column

You almost never form the Jacobian by symbolically differentiating f(q). Instead you build the geometric Jacobian directly from the frames you already computed for forward kinematics. Each joint contributes exactly one column, and the rule depends only on whether the joint is revolute or prismatic.

Let zᵢ be the unit vector of joint i's axis expressed in the base frame, pᵢ the position of joint i, and pₑ the position of the end-effector. Then:

Revolute joint i:    column = [ zᵢ × (pₑ − pᵢ) ]      ← linear part
                              [        zᵢ        ]      ← angular part

Prismatic joint i:   column = [        zᵢ        ]      ← linear part
                              [         0         ]      ← angular part

The cross product zᵢ × (pₑ − pᵢ) is the linear velocity a point at pₑ picks up when it rotates about an axis through pᵢ — exactly the rigid-body velocity formula v = ω × r. A revolute joint also spins the tool, so its angular part is the axis itself. A prismatic joint slides the whole downstream chain along its axis without rotating it, so it contributes zᵢ to the linear rows and nothing to the angular rows. Stack the n columns side by side and you have the 6×n geometric Jacobian, rebuilt every cycle because zᵢ, pᵢ, and pₑ all move as the arm moves.

The analytic Jacobian is a close cousin: instead of the angular-velocity vector ω in the bottom three rows, it uses the time derivative of whatever orientation parameterization you chose — Euler-angle rates or quaternion rates. The two are related by a representation matrix that itself becomes singular at certain orientations (gimbal lock for Euler angles), which is a representation artifact, not a physical robot singularity. For the three translational rows the geometric and analytic forms are identical. Controllers overwhelmingly use the geometric form precisely because it has no representation singularities of its own and drops straight out of the Denavit–Hartenberg transforms.

Worked example — a planar two-link arm

The cleanest way to see all of this is the planar 2R arm: two revolute joints, two links of length L₁ and L₂, the tool moving in a plane. Forward kinematics gives the tool position:

x = L₁·cos(θ₁) + L₂·cos(θ₁+θ₂)
y = L₁·sin(θ₁) + L₂·sin(θ₁+θ₂)

Differentiating with respect to θ₁ and θ₂ gives the 2×2 position Jacobian:

       ⎡ −L₁s₁ − L₂s₁₂    −L₂s₁₂ ⎤
J(θ) = ⎢                          ⎥        (s₁ = sin θ₁, s₁₂ = sin(θ₁+θ₂), etc.)
       ⎣  L₁c₁ + L₂c₁₂     L₂c₁₂ ⎦

det J = L₁ · L₂ · sin(θ₂)

Take L₁ = L₂ = 0.5 m and put the arm at θ₁ = 0°, θ₂ = 90° — a right-angle "L" pose. Then det J = 0.5 × 0.5 × sin(90°) = 0.25, comfortably nonzero, and the arm can move its tool freely in any planar direction. Command a tool velocity of ẋ = [0.1, 0]ᵀ m/s and invert: θ̇ = J⁻¹ ẋ returns finite, modest joint rates around 0.2 rad/s. Everything is well behaved.

Now drive θ₂ toward 0° — straighten the elbow. The determinant is 0.25·sin(θ₂), so it slides toward zero. At θ₂ = 0° the arm is fully extended, both links colinear, and det J = 0: a singularity. Physically the tool sits at the very edge of the workspace, 1.0 m out, and it simply cannot move any farther radially — no combination of joint speeds produces outward velocity. The two Jacobian columns have become parallel; the arm has lost the radial direction of motion entirely. The manipulability ellipsoid, normally a fat oval, has collapsed to a thin line tangent to the workspace boundary.

The danger is not the singularity itself but its neighborhood. At θ₂ = 2° the determinant is only 0.25·sin(2°) ≈ 0.0087. Inverting a near-singular matrix amplifies everything: a benign commanded tool speed of 0.1 m/s now demands joint rates of tens of rad/s, far beyond what any motor can deliver. The robot either saturates its drives, faults out, or — worst case — lurches as it tries. This is the single most common cause of "the robot jerked for no reason" on a production line, and it is entirely predictable from det J.

Force–torque duality — the same matrix, run backwards

The Jacobian's second job is the reason it is everywhere in force control. Power is conserved no matter what coordinates you use to describe it, so the mechanical power computed at the joints must equal the power computed at the tool:

τᵀ q̇  =  Fᵀ ẋ        (joint power = tool power)
       =  Fᵀ J q̇      (substitute ẋ = J q̇)

⇒  τ = Jᵀ F           (must hold for every q̇)

The transpose of the Jacobian maps an end-effector wrench F (three forces, three torques) to the joint torques needed to produce or resist it. This is profound in practice. To make a robot press its fingertip against a surface with 20 N, you do not need a force sensor at all — you compute τ = Jᵀ F with F = [0,0,−20,0,0,0]ᵀ and command those joint torques directly. Impedance control, hybrid force/position control, and admittance control all rest on this identity.

The duality also has a sharp engineering consequence: a manipulator is weakest exactly where it is fastest, and strongest where it is slowest. Where a column of J is long (large tool velocity per unit joint speed), the corresponding column of Jᵀ demands large joint torque per unit tool force — so the arm gives up output force to gain speed. Gear reducers exploit the slow end of this trade deliberately: a 100:1 harmonic drive multiplies torque 100× and divides speed 100×, and that ratio shows up directly in the relevant Jacobian column. Near a singularity, where the arm cannot move in some direction at all, the dual statement is that it can resist infinite force in that direction with zero joint torque — which is precisely why a fully-extended arm braces so well against an outward push.

Singularities — kinematic, boundary, and internal

A singularity is any pose where J loses rank, meaning the rows are no longer independent and the reachable set of tool velocities drops a dimension. They come in recognizable families:

• Boundary (workspace-limit) singularities. The arm is fully stretched out or fully folded, sitting on the edge of its reachable volume. The 2R example at θ₂ = 0° is exactly this. Unavoidable by geometry; you simply keep trajectories inside the boundary.
• Internal (wrist) singularities. The classic occurs on a six-axis arm with a spherical wrist when joints 4 and 6 become collinear (joint 5 at 0°). Two rotation axes coincide, so the wrist loses one rotational degree of freedom even though the tool is nowhere near the workspace edge. These are insidious because they sit in the middle of the workspace, right where useful tasks happen.
• Shoulder and elbow singularities. The wrist center crosses the axis of joint 1, or the arm straightens at the elbow. Each kills a different Cartesian direction.

The critical detail for software: do not detect singularities with the determinant. The determinant of a 6×6 Jacobian is a high-degree polynomial that stays large until you are almost on top of the singularity, then plunges — no useful warning. Instead, run a singular-value decomposition each cycle and watch the smallest singular value σ_min, or compute a manipulability index. The ratio σ_max / σ_min (the condition number) is the honest measure of how close you are and how badly the inverse will be amplified. Production motion planners reject or reshape any path whose condition number exceeds a threshold, often around 50–100.

Inverting the Jacobian — resolved-rate and pseudoinverse

Most six-axis robots have no closed-form inverse kinematics, so the workhorse is iterative and Jacobian-based. Resolved-rate motion control turns the velocity relation around:

Square (n = 6):     q̇ = J⁻¹ ẋ
Redundant (n > 6):  q̇ = J⁺ ẋ + (I − J⁺J) q̇₀     ← null-space term

For a redundant arm the Moore–Penrose pseudoinverse J⁺ = Jᵀ(J Jᵀ)⁻¹ picks the minimum-norm joint motion that achieves the commanded twist. The leftover term (I − J⁺J) q̇₀ lives in the null space: it is any joint motion that produces zero tool motion. That is what lets a seven-axis arm reposition its elbow around an obstacle, dodge a joint limit, or steer away from a singularity while its tool stays dead still on the path. Numerical inverse kinematics is then just Newton's method: take the pose error, treat it as a desired velocity, multiply by J⁺, step the joints, and iterate until the error is below tolerance — typically converging in a handful of iterations.

Near a singularity even the pseudoinverse blows up, so production controllers swap in damped least squares (the Levenberg–Marquardt regularization):

q̇ = Jᵀ (J Jᵀ + λ² I)⁻¹ ẋ

The damping term λ² bounds the joint speeds at the cost of a small tracking error in the lost direction — the arm gracefully gives up a little path accuracy instead of demanding 5000 °/s from a motor that can do 300. The damping is often scheduled to grow only as σ_min shrinks, so far from singularities the controller is exact and only blends in damping when it actually needs it.

Manipulability — how dexterous is this pose?

The Jacobian also scores the quality of a pose. Yoshikawa's manipulability index is the scalar

w = √det(J Jᵀ) = σ₁ · σ₂ · … · σ₆

which equals the product of the Jacobian's singular values and is proportional to the volume of the manipulability ellipsoid — the set of tool velocities reachable from a unit-norm joint-speed command. A round, fat ellipsoid means the arm moves equally well in all directions; a flat pancake means it is fast one way and almost frozen another; zero volume is a singularity. The ellipsoid's longest principal axis (largest singular value, longest column combination) points the direction of easiest motion; the shortest axis is the direction about to be lost. Cell designers place the workpiece where w is largest and choose link lengths to maximize it across the working region, and motion planners add w as a cost term to bias paths toward dexterous, well-conditioned configurations.

Jacobian methods compared

The Jacobian is one tool among several for getting a robot from a Cartesian command to joint commands. How it stacks up against the alternatives:

Property	Geometric Jacobian (resolved-rate)	Analytic / closed-form IK	Transpose Jacobian control	Damped least squares
What it maps	q̇ → ẋ and its inverse	x → q directly	force/error → torque	q̇ → ẋ, regularized
Needs matrix inverse	Yes (J⁻¹ or J⁺)	No	No (uses Jᵀ only)	Yes (small damped inverse)
Behavior at singularity	Blows up — joint speeds → ∞	No solution / loses a branch	Stable but slow convergence	Stable, bounded speeds
Works on redundant arms	Yes, with null-space term	Rarely (no general form)	Yes	Yes
Per-cycle cost	6×6 inverse, ~µs	Trig closed form, fastest	One matrix–vector product	SVD or 6×6 solve, ~µs
Typical use	Cartesian jogging, path tracking	Fast IK on calibrated 6R arms	Force control, simple servoing	Production motion near singularities

Where the Jacobian shows up

• Cartesian jogging and path tracking. Every "move the tool in a straight line in tool frame" command on an industrial controller (FANUC, ABB, KUKA) is resolved-rate control: the desired Cartesian velocity is multiplied by J⁻¹ at ~1 kHz to produce joint-rate setpoints.
• Surgical and teleoperated robots. The da Vinci system and haptic master devices map the surgeon's hand velocity to instrument velocity through the Jacobian, and reflect tool forces back to the hand through Jᵀ.
• Force and impedance control. Collaborative arms (Universal Robots UR series, Franka Panda) use τ = Jᵀ F to render a virtual spring at the tool — touch the arm and it yields with programmable stiffness, no external force sensor in the simplest schemes.
• Redundancy resolution. Seven-axis arms and humanoid limbs use the null space to satisfy a primary task (keep the hand on target) and a secondary objective (avoid joint limits, keep the elbow clear of an obstacle, maximize manipulability) simultaneously.
• Legged-robot whole-body control. The contact Jacobians of a quadruped's or humanoid's feet map ground-reaction wrenches to joint torques, and the same machinery balances the robot by distributing forces across the stance legs.
• Visual servoing. An image Jacobian (interaction matrix) relates camera-image feature velocities to robot motion, letting a camera-in-hand system drive features to target positions without an explicit 3-D reconstruction.

Common pitfalls when working with the Jacobian

• Mixing reference frames. J can be expressed in the base frame, the tool frame, or anywhere else, and the linear and angular rows must agree. Multiplying a base-frame Jacobian by a tool-frame velocity command silently produces garbage motion.
• Mixing units in the twist. Stacking metres-per-second on top of radians-per-second means the singular values are not comparable, so the condition number and manipulability index are meaningless unless you weight or scale the rows consistently. Always non-dimensionalize before computing a condition number.
• Detecting singularities with the determinant. It gives no warning until you are already inside the danger zone. Use the smallest singular value or the condition number from an SVD instead.
• Forgetting damping near singularities. A plain J⁻¹ at the edge of the workspace commands joint speeds the drives cannot deliver. Always fall back to damped least squares with singularity-aware damping.
• Confusing representation singularities with kinematic ones. Euler-angle gimbal lock in the analytic Jacobian is a coordinate artifact, not a robot limitation; the geometric Jacobian at the same pose is perfectly fine. Switch to quaternions or the geometric form rather than redesigning the arm.
• Ignoring the carrier of velocity at high speed. The Jacobian is a first-order, instantaneous map. Following a fast curved path also needs its time derivative J̇ for acceleration-level control; using only J at high feed rates introduces tracking lag.