ProjekinAja. Robotics Stage 2 · Kinematics Lesson 2.4
● Stage 2 · Lesson 2.4

The Jacobian: Velocity Kinematics and the Spine of Robotics

The Jacobian is not just 'the matrix of partial derivatives' — it is the object that connects geometry to velocity, force to torque, and proximity to disaster.

⏱ ~25 min read 📐 Velocity kinematics ⚡ Force & singularity

🎯 By the end you'll understand

How to construct the geometric Jacobian column-by-column from a DH chain — each column as a physical velocity contribution from one joint. The two-part structure: linear velocity rows and angular velocity rows, and what each means geometrically. How the Jacobian transpose maps end-effector forces back to joint torques — the static equilibrium condition. Why the Jacobian appears everywhere — in EKF linearization, force control, singularity analysis, and trajectory optimization. And the critical failure mode: using the pseudoinverse near a singularity without damping amplifies joint velocities to hardware-destroying magnitudes.

KEY INSIGHTA matrix that is geometry made algebraic

When a robot arm moves its joints, the end-effector traces a path in Cartesian space. The Jacobian is the precise, instantaneous description of that relationship — and it breaks down at exactly the configurations where the robot loses the ability to move in certain directions.

Most engineers first meet the Jacobian as "the matrix of partial derivatives of the forward kinematics function." That description is correct but bloodless. What it means physically is more useful: the Jacobian maps joint velocity vectors to end-effector velocity vectors. The i-th column of J tells you exactly what end-effector velocity you get when only joint i rotates (or translates) at unit rate, with all other joints frozen. This column-by-column interpretation is not just pedagogically convenient — it is the derivation.

🔑 Why "spine of robotics"

The Jacobian first appears here, in velocity kinematics. But you will see it again in every remaining stage. Stage 3 uses it for inverse dynamics and force control. Stage 4 uses its structure when linearizing the arm kinematics inside an EKF. Stage 5 uses it for sensor pose Jacobians in visual SLAM. Stage 6 uses it when writing trajectory optimization constraints. Every time a nonlinear function needs to be treated as locally linear, the Jacobian is the object that does the work. Learn it here, recognize it everywhere.

HOW IT WORKSBuilding the Jacobian column by column

Return to the DH chain from Lesson 2.3. You have a serial arm with n joints. The end-effector position in the base frame is p(q) — a nonlinear function of the joint variable vector q = [q₁, q₂, …, qₙ]ᵀ. The FK gives you position; the Jacobian gives you velocity. Taking the time derivative:

📖 The velocity relationship

If p(q) is the end-effector position, then ṗ = (∂p/∂q)·q̇ = J(q)·q̇. The full body velocity of the end-effector — including both linear and angular velocity — is ξ = J(q)·q̇, where ξ ∈ ℝ⁶ = [v ; ω] and J(q) ∈ ℝ⁶ˣⁿ. Each column Jᵢ of J is the contribution of joint i to ξ when q̇ᵢ = 1 and all other q̇ⱼ = 0.

The geometric Jacobian is derived directly from the DH frames without differentiating symbolically. The rule is simple and joint-type dependent:

Joint type Linear velocity column (top 3 rows) Angular velocity column (bottom 3 rows)
Revolute (rotation about zᵢ) zᵢ₋₁ × (pₑ − pᵢ₋₁) zᵢ₋₁
Prismatic (translation along zᵢ) zᵢ₋₁ 0

where zᵢ₋₁ is the z-axis of frame i−1 expressed in the base frame, pₑ is the end-effector position in the base frame, and pᵢ₋₁ is the origin of frame i−1 in the base frame. These come directly from the homogeneous transform chain T₀ₙ that the DH convention gives you — no symbolic differentiation needed.

For a 3-joint planar arm (all revolute, z-axes all pointing out of the page as ẑ = [0,0,1]ᵀ), the geometric Jacobian simplifies to a 6×3 matrix. The bottom 3 rows are all [0,0,1]ᵀ (every joint contributes the same angular velocity direction). The top 3 rows encode the 2D lever arms:

base p₀ q₂ L₁ q₃ L₂ E.E. L₃ J₁ joint 1 column J₂ joint 2 column J₃ joint 3 column q₁ Geometric J (3-DOF planar) Revolute: Jᵢ_linear = ẑ × (pₑ − pᵢ₋₁) Revolute: Jᵢ_angular = ẑ J₁ = ẑ × (pₑ − p₀) [largest] J₂ = ẑ × (pₑ − p₁) [medium] J₃ = ẑ × (pₑ − p₂) [smallest] magnitude ∝ distance to E.E. Note: when arm fully extended, J₁, J₂, J₃ all point in the same direction → det(J·Jᵀ) → 0 → singularity
The three columns of J for a 3-joint planar arm visualized as end-effector velocity arrows when each joint rotates alone at unit rate. J₁ (red) has the longest lever and produces the largest end-effector velocity. J₃ (green) has the shortest lever. At full extension, all three arrows align — this is the singular configuration.

The key physical insight: the magnitude of Jᵢ's linear part equals the distance from joint i to the end-effector. The farther the joint is from the tool tip, the larger its velocity contribution — and the more important it is to control accurately. Near a singularity, the columns of J become linearly dependent (they all point in the same direction), and the matrix's rank drops — the arm literally loses a degree of freedom in task space, even though all its joints still move.

Computing J in Python using scipy and numpy requires only the forward kinematics matrices you already have from the DH chain:

jacobian_planar.pynumpy · geometric Jacobian
import numpy as np

def geometric_jacobian_planar(q, L):
    """
    3-joint planar arm (all revolute, z-axes = [0,0,1]^T).
    q: [q1, q2, q3] joint angles (rad)
    L: [L1, L2, L3] link lengths (m)
    Returns J (6×3): top 3 rows = linear velocity, bottom 3 = angular.
    """
    z = np.array([0.0, 0.0, 1.0])  # all z-axes point out of page

    # Joint origins in base frame (2D, lifted to 3D)
    p0 = np.array([0.0, 0.0, 0.0])
    p1 = p0 + np.array([L[0]*np.cos(q[0]),
                          L[0]*np.sin(q[0]),
                          0.0])
    p2 = p1 + np.array([L[1]*np.cos(q[0]+q[1]),
                          L[1]*np.sin(q[0]+q[1]),
                          0.0])
    pe = p2 + np.array([L[2]*np.cos(q[0]+q[1]+q[2]),
                          L[2]*np.sin(q[0]+q[1]+q[2]),
                          0.0])

    J = np.zeros((6, 3))

    # Each column: revolute → linear = z × (pe - pi), angular = z
    for i, pi in enumerate([p0, p1, p2]):
        diff = pe - pi
        J[:3, i] = np.cross(z, diff)   # linear velocity contribution
        J[3:, i] = z                       # angular velocity contribution

    return J

# Manipulability measure: sqrt(det(J·Jᵀ))  (Yoshikawa 1985)
def manipulability(J):
    J_lin = J[:2, :]          # use 2D linear part for planar arm
    JJT   = J_lin @ J_lin.T
    det   = np.linalg.det(JJT)
    return float(np.sqrt(np.maximum(0.0, det)))
💡 Analytic vs. geometric Jacobian

There are two Jacobians in robotics. The analytic Jacobian differentiates the minimal orientation representation (e.g., Euler angles) symbolically — it's compact but has singularities tied to the representation, not the geometry. The geometric Jacobian works with the body angular velocity directly and avoids representation singularities. For control purposes, the geometric Jacobian is almost always preferred. Some older robotics textbooks use the analytic form exclusively — be aware that the two are related by a transformation matrix that depends on the orientation representation.

CORE CONCEPTJacobian transpose: from end-effector force to joint torques

The Jacobian has a dual that is just as important as the velocity mapping. Suppose the end-effector exerts a wrench (force + torque) F ∈ ℝ⁶ on the environment. What joint torques τ ∈ ℝⁿ are required to maintain static equilibrium? The answer is the virtual work principle:

📖 Static force mapping via virtual work

For a displacement δq in joint space, the work done in Cartesian space is δWₓ = Fᵀ · J · δq. Setting this equal to the joint torque work δWₒ = τᵀ · δq and requiring equality for all δq gives: τ = Jᵀ(q) · F. No matrix inversion required — just the transpose. This holds exactly at static equilibrium; for dynamic motion, inertia and Coriolis terms appear (Stage 3).

The Jᵀ mapping is used constantly in force control. If FollowBot's arm needs to push on a surface with a desired force vector F_desired, the required joint torques are τ = Jᵀ · F_desired — you can compute these without a Cartesian force sensor, just from the desired force and the current configuration's Jacobian. Force control (Stage 3) builds an entire control architecture on top of this.

The transpose also reveals the geometry of force transmission. A force applied in the direction of a Jacobian column does positive work for exactly one joint — which tells you which joint "feels" that force most strongly. At a singularity, certain force directions require infinite joint torques to resist — this is the force dual of the velocity problem, and it is why robot singularities are dangerous both when commanding motion (velocity amplification) and when resisting contact (torque amplification).

Joint Space q̇ ∈ ℝⁿ (velocities) τ ∈ ℝⁿ (torques) n joints Task Space ξ ∈ ℝ⁶ (velocity) F ∈ ℝ⁶ (wrench) 6-DOF end-effector ξ = J · q̇ τ = Jᵀ · F Velocity–Force Duality (Virtual Work Principle) The same matrix J governs both mappings. No inversion needed for Jᵀ.
The Jacobian governs both directions of the velocity–force duality. Forward: joint velocities to end-effector body velocity. Backward (transpose): end-effector wrench to joint torques. The transpose needs no matrix inversion and is exact at static equilibrium.

SEE ITJacobian column visualizer — approach a singularity

The widget below shows a 3-joint planar arm. Use the sliders to set each joint angle, then toggle which joints are contributing (columns of J). The colored arrows show the end-effector velocity each joint would produce at unit rate. Watch what happens as you move the arm toward full extension: the arrows align, det(J) collapses toward zero, and manipulability drops — the arm is losing task-space degrees of freedom. This is what the math is warning you about before hardware gets damaged.

⚙ Interactive · Jacobian Column Visualizer

Set joint angles. Toggle joints on/off to see each column of J. Move toward full extension (q₁ = q₂ = q₃ ≈ 0°) to witness singularity collapse. Det(J) and manipulability update live.

45°
60°
30°
Toggle J columns (which joints contribute):
det(JJᵀ)
—
Manipulability w
—
Condition number κ
—
Status
—
base origin J₁ J₂ J₃ J₁: joint 1 contribution J₂: joint 2 contribution J₃: joint 3 contribution Link lengths: L₁=110, L₂=80, L₃=60 (px)
  • J₁ — lever arm = |pₑ − p₀|; always the largest column (farthest from E.E.). Controls the broadest arc of motion.
  • J₂ — lever arm = |pₑ − p₁|; medium. Disabling this joint kills gross positioning ability.
  • J₃ — lever arm = |pₑ − p₂|; smallest. Fine orientation control. At singularity, J₃ aligns with J₁ and J₂.

The widget makes the singularity viscerally clear: when you push all joint angles toward zero (arm extended straight), the three velocity arrows converge to near-parallel. Det(JJᵀ) → 0. The manipulability measure w = √det(JJᵀ) → 0. The arm has effectively lost a task-space degree of freedom — it can no longer move the end-effector perpendicular to the arm's extension axis without enormous joint velocities. This is exactly the condition the Damped Least Squares inverse (next lesson) is designed to handle.

IN PRACTICEWhere the Jacobian keeps showing up

The Jacobian is not a concept you use once in velocity kinematics and put aside. It recurs across every stage of the course — always doing the same job (locally linearizing a nonlinear function) but in different algorithmic contexts.

1

Singularity analysis and manipulability (Lesson 2.5)

The singular configurations of the arm are exactly the configurations where J loses rank. The manipulability ellipsoid — whose axes are the singular values of J and whose directions are the right singular vectors — tells you how "well-conditioned" the current configuration is for producing arbitrary end-effector velocities. Near a singularity, the ellipsoid collapses to a disk or line. This is treated quantitatively in Lesson 2.5; the widget above gives you the intuition now.

2

Inverse kinematics via the pseudoinverse (Lesson 2.6)

Given a desired end-effector velocity ξ_d, the joint velocities that produce it are q̇ = J⁺ · ξ_d, where J⁺ is the Moore-Penrose pseudoinverse. This only works when J is well-conditioned. Near a singularity, J⁺ amplifies small ξ_d into enormous q̇ — the critical failure mode described in the brief for this lesson, and the reason Damped Least Squares (DLS) exists: q̇ = Jᵀ(JJᵀ + λ²I)⁻¹ · ξ_d.

3

EKF linearization in state estimation (Stage 4)

When the Extended Kalman Filter propagates a state estimate through a nonlinear observation function h(x), it needs the Jacobian H = ∂h/∂x to compute the innovation covariance S = HPHᵀ + R. For FollowBot's arm, if the EKF is tracking the arm's end-effector pose using visual markers, the observation model is the FK function — and the EKF needs its Jacobian every update cycle. The structure is identical to what you derived above.

4

Impedance and force control (Stage 3)

Impedance control commands the arm to behave like a spring-damper in Cartesian space. The relationship between joint torques and Cartesian forces uses Jᵀ at its core: τ_impedance = Jᵀ(q) · F_cart + τ_gravity(q). The arm's inertia in Cartesian space — the operational space inertia matrix — is (J M⁻¹ Jᵀ)⁻¹, where M is the joint-space inertia matrix. Getting this wrong near a singularity produces the same catastrophic velocity amplification, now in the force domain.

5

Trajectory optimization (Stage 6)

Trajectory optimization formulates arm motion as a constrained optimization problem. The constraints — end-effector must stay in a collision-free box, must approach a surface from a specific direction — are expressed as functions of q. Their Jacobians (∂constraint/∂q) are the entries in the constraint Jacobian matrix that the optimizer's KKT conditions require. Again, the same structure: a locally-linear approximation of a nonlinear function evaluated at the current configuration.

💡 When is the Jacobian not enough?

The Jacobian is a first-order (linear) approximation. It is exact at the current configuration and increasingly inaccurate farther away. For high-speed motions or large trajectory steps, higher-order terms (the Hessian of FK) matter. For online control at 1 kHz — the typical rate — the approximation is recomputed every millisecond, so error barely accumulates. The region where the linear approximation breaks down is precisely the neighborhood of a singularity: J is nearly rank-deficient, the linear model is locally degenerate, and even a tiny step in the configuration causes the linearization to shift dramatically. This is a second reason to avoid singularities in high-speed operation.

FOLLOWBOTArm Jacobian implementation and singularity monitor

FollowBot's stage-2 milestone includes a live Jacobian computation node for the 6-DOF arm. The node subscribes to /arm/joint_states, computes J at every configuration update, publishes the manipulability measure to /arm/manipulability, and raises a diagnostic warning when manipulability drops below a safe threshold — preventing the IK solver from issuing joint commands that would destroy the gearboxes.

arm_jacobian_monitor.pyrclpy · ROS 2 Humble · manipulability guard
import rclpy
from rclpy.node import Node
import numpy as np
from sensor_msgs.msg import JointState
from std_msgs.msg import Float32, Bool

# DH parameters: [a, alpha, d, theta_offset] for each joint (meters, radians)
DH_PARAMS = [
    [0.0,   np.pi/2, 0.100, 0.0],   # joint 1
    [0.250, 0.0,     0.0,   0.0],   # joint 2
    [0.210, 0.0,     0.0,   0.0],   # joint 3
    [0.0,   np.pi/2, 0.0,   0.0],   # joint 4
    [0.0,  -np.pi/2, 0.120, 0.0],   # joint 5
    [0.0,   0.0,     0.065, 0.0],   # joint 6 (wrist)
]
MANIP_THRESHOLD = 0.004  # below this → near-singular; DLS required

def dh_transform(a, alpha, d, theta):
    """Single DH homogeneous transform T_{i-1,i}."""
    ca, sa = np.cos(alpha), np.sin(alpha)
    ct, st = np.cos(theta), np.sin(theta)
    return np.array([
        [ct,  -st*ca,  st*sa, a*ct],
        [st,   ct*ca, -ct*sa, a*st],
        [0,    sa,     ca,    d   ],
        [0,    0,      0,     1   ],
    ])

def geometric_jacobian_6dof(q):
    """6×6 geometric Jacobian for a 6-DOF revolute arm using DH convention."""
    n = len(q)
    T = np.eye(4)
    origins = [T[:3, 3].copy()]
    z_axes  = [T[:3, 2].copy()]

    for i in range(n):
        a, alpha, d, t0 = DH_PARAMS[i]
        T = T @ dh_transform(a, alpha, d, q[i] + t0)
        origins.append(T[:3, 3].copy())
        z_axes.append(T[:3, 2].copy())

    pe = origins[-1]
    J  = np.zeros((6, n))
    for i in range(n):                     # all joints revolute
        J[:3, i] = np.cross(z_axes[i], pe - origins[i])
        J[3:, i] = z_axes[i]
    return J

class JacobianMonitor(Node):
    def __init__(self):
        super().__init__('jacobian_monitor')
        self.create_subscription(JointState, '/arm/joint_states',
                                  self.cb, 10)
        self.pub_manip = self.create_publisher(Float32, '/arm/manipulability', 10)
        self.pub_sing  = self.create_publisher(Bool, '/arm/near_singular', 10)

    def cb(self, msg):
        q = np.array(msg.position[:6])
        J = geometric_jacobian_6dof(q)
        JJT = J @ J.T
        w = float(np.sqrt(np.maximum(0.0, np.linalg.det(JJT))))
        self.pub_manip.publish(Float32(data=w))
        near_sing = w < MANIP_THRESHOLD
        self.pub_sing.publish(Bool(data=near_sing))
        if near_sing:
            self.get_logger().warn(
                f'Near-singular: w={w:.4f}. IK solver must use DLS (λ≥0.05).'
            )

def main():
    rclpy.init()
    rclpy.spin(JacobianMonitor())
    rclpy.shutdown()

if __name__ == '__main__':
    main()

This node publishes to /arm/near_singular — a Bool topic that the IK solver subscribes to. When near_singular is True, the IK solver switches from the raw pseudoinverse to Damped Least Squares. The manipulability value is logged to RViz via a custom display plugin and shown on FollowBot's operator dashboard. This is the first concrete piece of FollowBot's singularity protection layer.

🔑 Stage 2 milestone — Arm kinematics status

At the end of Stage 2, FollowBot has: (1) a diff-drive kinematic model publishing /odom from wheel encoder integration; (2) FK implemented from DH parameters, publishing the arm's end-effector pose as a TF frame arm_ee; (3) this Jacobian monitor running at 100 Hz, guarding every IK call; and (4) a workspace visualization in RViz showing the reachable volume. The IK solver (Lesson 2.6) will consume all of these and add the inverse model to close the loop on Cartesian arm control.

WEAKNESSWhere the Jacobian bites — and how hardware breaks

✗ Using J⁺ near a singularity without damping — the hardware destruction path

This is the critical failure mode from the lesson brief. The pseudoinverse J⁺ = Jᵀ(JJᵀ)⁻¹ requires inverting JJᵀ. Near a singularity, JJᵀ is nearly singular — its smallest eigenvalue approaches zero. The inversion amplifies any component of ξ_d along the degenerate direction by 1/σ_min, where σ_min is the smallest singular value. If σ_min = 0.01 and ξ_d has a 0.01 m/s component in that direction, the commanded q̇ contains a 1 rad/s contribution from that amplification alone. At σ_min = 0.001, it becomes 10 rad/s per 0.01 m/s input. Real gearboxes and motors cannot absorb joint velocity spikes of 10–100 rad/s. Damped Least Squares replaces (JJᵀ)⁻¹ with (JJᵀ + λ²I)⁻¹, capping amplification at 1/λ. The cost is reduced Cartesian accuracy near singularities — a tradeoff you choose consciously, not discover by breaking hardware.

✗ Confusing the 6×n Jacobian rank with task-space reachability

A 6-DOF arm has a 6×6 Jacobian. When rank(J) = 6, the arm can instantaneously produce any desired 6-DOF end-effector velocity — it is "full rank" locally. But rank is a local, configuration-dependent property. An arm that is full rank at 99% of configurations can be rank-deficient at specific joint angle combinations (singularities). More subtly: a 7-DOF arm (redundant) has a 6×7 Jacobian. It always has a non-trivial null space — there exist joint velocity vectors q̇ in the null space of J that produce zero end-effector velocity. Redundancy gives you extra freedom to avoid singularities or obstacles, but the Jacobian computation changes: J⁺ for a tall matrix (underdetermined system) gives the minimum-norm solution, not the least-squares solution. Confusing the two leads to wrong IK solutions and unexpected joint trajectories on hardware.

✗ Recomputing the Jacobian too infrequently in high-speed motion

The Jacobian is a function of the current joint configuration q. It must be recomputed every control cycle. In Python/rclpy, a naive Jacobian computation using symbolic sympy differentiation can take 5–50 ms — dangerously close to or exceeding the 10 ms budget of a 100 Hz control loop. The production pattern: derive the closed-form geometric Jacobian analytically (as in the code above) and hard-code it as a numpy vectorized function. This runs in under 0.1 ms. Sympy is for derivation on your development machine; compiled numpy (or C++) is for the control loop on the robot. Every millisecond of Jacobian evaluation latency you add is a millisecond of stale linearization point, which degrades controller performance and can cause instability at high speeds.

KEY INSIGHTHow it connects

The Jacobian is also the first concept in Stage 2 that carries forward unchanged into every later stage. When you see "linearize the observation function," "operational space control," or "constraint Jacobian" in later lessons, it is the same mathematical object — a matrix of partial derivatives evaluated at the current state. Building a solid geometric and computational intuition for it here pays dividends across the entire course.

GLOSSARYKey terms introduced

Geometric Jacobian
The 6×n matrix J(q) that maps joint velocity vectors q̇ to the 6-DOF body velocity (linear + angular) of the end-effector, ξ = J·q̇. Constructed column-by-column from the DH frames without symbolic differentiation: revolute joints contribute ẑᵢ₋₁ × (pₑ − pᵢ₋₁) to the linear part and ẑᵢ₋₁ to the angular part.
Jacobian transpose (Jᵀ)
The mapping from end-effector wrench F ∈ ℝ⁶ to joint torques τ ∈ ℝⁿ via the virtual work principle: τ = Jᵀ·F. Requires no matrix inversion. Exact at static equilibrium; forms the basis of force and impedance control in Stage 3.
Manipulability measure
A scalar w = √det(JJᵀ) (Yoshikawa 1985) quantifying how far a configuration is from a singularity. w = 0 at a singular configuration; larger w indicates better-conditioned control. Used as a live metric to trigger DLS switching in FollowBot's IK solver.
Singularity (kinematic)
A configuration q at which the Jacobian J(q) loses rank — the arm cannot produce end-effector velocities in one or more directions. Characterized by det(J) = 0 (for square J) or det(JJᵀ) = 0. Near-singular configurations cause joint velocity amplification via the pseudoinverse.
Pseudoinverse (J⁺)
The Moore-Penrose generalized inverse. For underdetermined systems (n > m, more joints than task DOFs — the common redundant robot case): J⁺ = Jᵀ(JJᵀ)⁻¹, giving the minimum-norm joint velocity solution. For overdetermined systems (n < m, fewer joints than task DOFs): J⁺ = (JᵀJ)⁻¹Jᵀ, giving the least-squares solution. Numerically unstable near singularities without damping.
Damped Least Squares (DLS)
A regularized pseudoinverse q̇ = Jᵀ(JJᵀ + λ²I)⁻¹ · ξ_d that caps joint velocity amplification at 1/λ near singularities. The damping factor λ is chosen to balance Cartesian tracking accuracy (small λ) and joint velocity safety (large λ). λ can also be made configuration-dependent (variable damping).
Null space (of J)
The set of joint velocity vectors q̇ such that J·q̇ = 0 — joint motions that produce no end-effector motion. Exists when n > 6 (redundant arm). The null space can be used for secondary objectives: avoiding joint limits, steering away from singularities, or avoiding self-collision, without disturbing the primary task velocity.
Condition number (κ)
The ratio σ_max/σ_min of the largest to smallest singular values of J. κ = 1 is ideal (isotropic); κ → ∞ near a singularity. A condition number above ~50–100 typically indicates the configuration should be avoided for precision control tasks.

ACTIVE RECALLCheck your understanding

Answer in your own words first, then reveal.

1What does the i-th column of the geometric Jacobian represent physically, and how do you compute it for a revolute joint from the DH chain?›

The i-th column Jᵢ represents the 6-DOF end-effector velocity you would get if joint i were the only one moving at unit rate (q̇ᵢ = 1) while all others are frozen. Physically: it is the velocity contribution of joint i to the end-effector, decomposed into linear and angular parts. For a revolute joint, the linear part is ẑᵢ₋₁ × (pₑ − pᵢ₋₁) — the cross product of the joint's rotation axis with the lever arm from that joint to the end-effector. The angular part is simply ẑᵢ₋₁ — the joint's rotation axis contributes directly to end-effector angular velocity. Both quantities come directly from the homogeneous transforms T₀ᵢ computed by the DH chain; no symbolic differentiation is needed.

2Why does the Jacobian transpose (Jᵀ) map end-effector forces to joint torques without requiring matrix inversion?›

The answer comes from the virtual work principle. For a virtual joint displacement δq, the virtual work done in Cartesian space is δWₓ = Fᵀ · (J · δq) = (Fᵀ J) · δq. The virtual work done at the joints is δWₒ = τᵀ · δq. For equilibrium, δWₓ = δWₒ for all δq, which gives τᵀ = Fᵀ J, or equivalently τ = Jᵀ F. The transpose is an algebraic operation on J — it requires no inversion because the original relationship (F → τ) goes in the direction opposite to the Jacobian's original mapping (q̇ → ξ). This is the velocity-force duality: the same geometric object that maps joint velocities to task velocities, when transposed, maps task forces to joint torques.

3FollowBot's arm is near full extension and the IK solver commands a joint velocity of 18 rad/s on joint 2. What has likely gone wrong, and how do you prevent it?›

The arm is near a kinematic singularity and the IK solver is using the raw pseudoinverse J⁺. Near a singularity, the smallest singular value σ_min of J approaches zero. The pseudoinverse amplifies any component of the desired end-effector velocity ξ_d along the degenerate direction by 1/σ_min. Even a small desired Cartesian velocity in that direction becomes an enormous joint velocity. A command of 18 rad/s will exceed FollowBot's motor and gearbox limits (typically 5–8 rad/s), causing mechanical damage or triggering an emergency stop. The fix is Damped Least Squares: replace J⁺ with Jᵀ(JJᵀ + λ²I)⁻¹. This bounds the worst-case amplification to 1/λ regardless of how close the configuration is to singularity. Set λ based on the maximum safe joint velocity and the minimum acceptable Cartesian accuracy near the singular configuration. The manipulability monitor (publishing to /arm/near_singular) triggers this switch before the dangerous command is ever issued.

4The Jacobian appears in EKF linearization in Stage 4. What role does it play there, and how is it structurally different from the arm velocity Jacobian derived in this lesson?›

In the Extended Kalman Filter, the measurement update requires linearizing the nonlinear observation function h(x) around the current state estimate x̂. The linearization is H = ∂h/∂x |_{x=x̂} — the Jacobian of h with respect to the state vector x. This is the same mathematical operation as what was done here: take a nonlinear function and compute the matrix of partial derivatives at the current operating point. The structural difference is in what function is being differentiated and what the input/output spaces are. In velocity kinematics, the function is the forward kinematics p(q), the input is the joint configuration q, and the output is the end-effector velocity. In EKF, the function is the sensor observation model h(x) (e.g., how a visual marker projects onto the camera sensor given the robot state), the input is the state vector x (pose, velocity, etc.), and the output is the expected measurement. The computation is analogous; the physical meaning is different. Recognizing this shared structure is what makes the Jacobian the "spine of robotics" — one concept, many applications.

Next: singularity analysis and the manipulability ellipsoid →