Recall from differential kinematics (Chapter 7) that for an \( n \)-DOF serial manipulator the joint velocity vector \( \dot{\mathbf{q}} \in \mathbb{R}^n \) and the end-effector twist \( \mathbf{v} \in \mathbb{R}^6 \) are related by the Jacobian:

\[ \mathbf{v} = \begin{bmatrix} \boldsymbol{\omega} \\[4pt] \mathbf{v}_\text{lin} \end{bmatrix} = \mathbf{J}(\mathbf{q})\,\dot{\mathbf{q}}, \qquad \mathbf{J}(\mathbf{q}) \in \mathbb{R}^{6 \times n}. \]

In statics we are interested in the dual quantities: joint torques/forces \( \boldsymbol{\tau} \in \mathbb{R}^n \) and end-effector wrench \( \mathbf{F} \in \mathbb{R}^6 \), where \( \mathbf{F} = [\mathbf{n}^\top \; \mathbf{f}^\top]^\top \) stacks moment and force components (in a chosen frame). The key result of this lesson is the static mapping

\[ \boldsymbol{\tau} = \mathbf{J}(\mathbf{q})^\top \mathbf{F}, \]

which expresses how an end-effector wrench is transmitted to joint torques through the manipulator geometry. Intuitively, each column of \( \mathbf{J} \) describes how joint motion affects the end-effector; the transpose tells how an end-effector wrench projects back onto each joint.

flowchart TD
  Q["Joint coordinates q"] --> J["Jacobian J(q)"]
  J --> V["Twist v = J(q) * qdot"]
  F["Task wrench F"] --> T["Joint torques tau = J(q)^T * F"]
  V --> P["Power at task: P = F^T * v"]
  T --> P2["Power at joints: P = tau^T * qdot"]
  P & P2 --> EQ["Energy consistency"]
        

The rest of the lesson rigorously derives this mapping via virtual work, studies its properties, and illustrates its use on concrete examples and implementations.

From Lesson 2 (Virtual Work), a generalized force is defined so that the virtual work done under a virtual displacement is \( \delta W = \mathbf{g}^\top \delta \mathbf{q} \) in generalized coordinates. For a manipulator:

• Joint space generalized forces: \( \boldsymbol{\tau} \in \mathbb{R}^n \), virtual joint displacement \( \delta \mathbf{q} \in \mathbb{R}^n \): \( \delta W_\text{joint} = \boldsymbol{\tau}^\top \delta \mathbf{q} \).
• Task-space wrench: \( \mathbf{F} \in \mathbb{R}^6 \), virtual twist \( \delta \mathbf{x} \in \mathbb{R}^6 \) (small displacement and rotation): \( \delta W_\text{task} = \mathbf{F}^\top \delta \mathbf{x} \).

For a rigid manipulator with no internal dissipation, the virtual work seen at joints and at the end-effector must coincide for any admissible virtual displacement:

\[ \delta W_\text{joint} = \delta W_\text{task} \quad\Rightarrow\quad \boldsymbol{\tau}^\top \delta \mathbf{q} = \mathbf{F}^\top \delta \mathbf{x}. \]

For small motions around a configuration \( \mathbf{q} \), the differential kinematics yields

\[ \delta \mathbf{x} = \mathbf{J}(\mathbf{q})\,\delta \mathbf{q}. \]

Substituting into the virtual work equality:

\[ \boldsymbol{\tau}^\top \delta \mathbf{q} = \mathbf{F}^\top \mathbf{J}(\mathbf{q})\,\delta \mathbf{q}. \]

Factor out the common virtual displacement \( \delta \mathbf{q} \):

\[ \left( \boldsymbol{\tau}^\top - \mathbf{F}^\top \mathbf{J}(\mathbf{q}) \right)\delta \mathbf{q} = 0. \]

Because the above must hold for all virtual joint displacements \( \delta \mathbf{q} \), the only possibility is

\[ \boldsymbol{\tau}^\top = \mathbf{F}^\top \mathbf{J}(\mathbf{q}) \quad\Rightarrow\quad \boldsymbol{\tau} = \mathbf{J}(\mathbf{q})^\top \mathbf{F}. \]

This derivation is completely general: the same Jacobian that maps joint velocities to end-effector twist also maps wrenches to joint torques via its transpose, due to conservation of virtual work.

2.1 Power Consistency

Replacing virtual displacements by actual velocities, the instantaneous power at the joints and in task space are

\[ P_\text{joint} = \boldsymbol{\tau}^\top \dot{\mathbf{q}}, \qquad P_\text{task} = \mathbf{F}^\top \mathbf{v}. \]

Using \( \mathbf{v} = \mathbf{J}\dot{\mathbf{q}} \) and \( \boldsymbol{\tau} = \mathbf{J}^\top \mathbf{F} \),

\[ P_\text{task} = \mathbf{F}^\top \mathbf{J}\dot{\mathbf{q}} = (\mathbf{J}^\top \mathbf{F})^\top \dot{\mathbf{q}} = \boldsymbol{\tau}^\top \dot{\mathbf{q}} = P_\text{joint}. \]

Thus the Jacobian transpose mapping preserves power: no (ideal) energy is lost or gained in the kinematic transmission.

3.1 Dimensionality and Singularities

For an \( n \)-DOF manipulator with a 6D task space, \( \mathbf{J}(\mathbf{q}) \in \mathbb{R}^{6 \times n} \). The mapping \( \mathbf{F} \mapsto \boldsymbol{\tau} = \mathbf{J}^\top \mathbf{F} \) is always well-defined (for any \( \mathbf{F} \)), but the inverse mapping from joint torques to wrench depends on rank.

• If \( n = 6 \) and \( \mathbf{J}(\mathbf{q}) \) is nonsingular (full rank), then \( \mathbf{F} = \mathbf{J}(\mathbf{q})^{-\top} \boldsymbol{\tau} \).
• If \( n > 6 \) (redundant manipulator), multiple joint torque vectors yield the same wrench. Internal torque components in \( \ker(\mathbf{J}^\top) \) do not affect the end-effector wrench.
• If \( \mathbf{J}(\mathbf{q}) \) is rank-deficient (kinematic singularity), some wrench directions cannot be generated regardless of the available joint torques.

At a singular configuration, the ability to generate wrenches in certain task directions collapses. Even away from exact singularities, poor conditioning of \( \mathbf{J} \) amplifies the joint torques needed to realize a given wrench, linking directly with the manipulability concepts from Chapter 8.

3.2 Internal Torques and Null Space

Let \( \mathcal{R}(\mathbf{J}^\top) \) denote the range (column space) of \( \mathbf{J}^\top \) and \( \mathcal{N}(\mathbf{J}^\top) \) its null space. For any wrench \( \mathbf{F} \), the corresponding joint torque is

\[ \boldsymbol{\tau}_\text{ext} = \mathbf{J}^\top \mathbf{F} \in \mathcal{R}(\mathbf{J}^\top). \]

Any torque vector of the form

\[ \boldsymbol{\tau} = \boldsymbol{\tau}_\text{ext} + \boldsymbol{\tau}_\text{int}, \qquad \boldsymbol{\tau}_\text{int} \in \mathcal{N}(\mathbf{J}^\top), \]

produces the same end-effector wrench. The term \( \boldsymbol{\tau}_\text{int} \) corresponds to internal forces that do not affect the net wrench but can overload joints or internal structures (especially in closed chains, studied later in the course).

In Chapter 8 we introduced velocity manipulability ellipsoids, describing the set of end-effector velocities achievable under unit joint speed constraints. Using the Jacobian transpose mapping, we obtain the dual notion: force manipulability, describing the set of wrenches achievable under bounded joint torques.

Assume an isotropic joint torque limit such that admissible torques satisfy \( \boldsymbol{\tau}^\top \boldsymbol{\tau} \leq \tau_\text{max}^2 \). Using \( \boldsymbol{\tau} = \mathbf{J}^\top \mathbf{F} \), the induced set of task wrenches is

\[ \mathcal{W}(\mathbf{q}) = \left\{ \mathbf{F} \in \mathbb{R}^6 \;\middle|\; \mathbf{F}^\top \mathbf{J}(\mathbf{q}) \mathbf{J}(\mathbf{q})^\top \mathbf{F} \leq \tau_\text{max}^2 \right\}. \]

When \( \mathbf{J}(\mathbf{q}) \) has full row rank, \( \mathbf{J}\mathbf{J}^\top \) is symmetric positive definite and the above describes an ellipsoid in wrench space. Its principal axes and eigenvalues quantify how effectively the manipulator can generate wrenches in different directions at configuration \( \mathbf{q} \).

Short axes indicate directions where large joint torques are required to generate modest wrenches (poor static transmission), while long axes indicate directions of strong mechanical advantage.

Consider a planar 2R manipulator in the horizontal plane with link lengths \( \ell_1, \ell_2 \) and joint angles \( q_1, q_2 \). The end-effector position is

\[ x = \ell_1 \cos q_1 + \ell_2 \cos(q_1 + q_2), \qquad y = \ell_1 \sin q_1 + \ell_2 \sin(q_1 + q_2). \]

The translational Jacobian \( \mathbf{J}_v(q_1,q_2) \in \mathbb{R}^{2 \times 2} \) is obtained by differentiation:

\[ \mathbf{J}_v(q_1,q_2) = \begin{bmatrix} \dfrac{\partial x}{\partial q_1} & \dfrac{\partial x}{\partial q_2} \\ \dfrac{\partial y}{\partial q_1} & \dfrac{\partial y}{\partial q_2} \end{bmatrix} = \begin{bmatrix} -\ell_1 \sin q_1 - \ell_2 \sin(q_1 + q_2) & -\ell_2 \sin(q_1 + q_2) \\ \ell_1 \cos q_1 + \ell_2 \cos(q_1 + q_2) & \ell_2 \cos(q_1 + q_2) \end{bmatrix}. \]

Let the end-effector force in the plane be \( \mathbf{f} = [F_x \; F_y]^\top \). Neglecting out-of-plane moments, the static mapping becomes

\[ \boldsymbol{\tau} = \mathbf{J}_v(q_1,q_2)^\top \mathbf{f} = \begin{bmatrix} -\ell_1 \sin q_1 - \ell_2 \sin(q_1 + q_2) & \ell_1 \cos q_1 + \ell_2 \cos(q_1 + q_2) \\ -\ell_2 \sin(q_1 + q_2) & \ell_2 \cos(q_1 + q_2) \end{bmatrix} \begin{bmatrix} F_x \\ F_y \end{bmatrix}. \]

Expanding the components:

\[ \begin{aligned} \tau_1 &=& \left(-\ell_1 \sin q_1 - \ell_2 \sin(q_1 + q_2)\right) F_x + \left(\ell_1 \cos q_1 + \ell_2 \cos(q_1 + q_2)\right) F_y, \\[4pt] \tau_2 &=& \left(-\ell_2 \sin(q_1 + q_2)\right) F_x + \left(\ell_2 \cos(q_1 + q_2)\right) F_y. \end{aligned} \]

As a simple numeric case, take \( \ell_1 = \ell_2 = 1 \), \( q_1 = 0, q_2 = 0 \) (fully stretched along the positive \( x \)-axis), and a downward force \( \mathbf{f} = [0 \; -10]^\top \). Then

\[ \mathbf{J}_v(0,0) = \begin{bmatrix} 0 & 0 \\ 2 & 1 \end{bmatrix}, \qquad \boldsymbol{\tau} = \mathbf{J}_v(0,0)^\top \mathbf{f} = \begin{bmatrix} 2 & 1 \\ 0 & 1 \end{bmatrix} \begin{bmatrix} 0 \\ -10 \end{bmatrix} = \begin{bmatrix} -20 \\ -10 \end{bmatrix}. \]

Joint 1 must supply \( -20 \) (Nm) and joint 2 \( -10 \) (Nm) to balance the downward load at that configuration, assuming an ideal (frictionless, massless) mechanism.

We now implement the mapping \( \boldsymbol{\tau} = \mathbf{J}^\top \mathbf{F} \) for the 2R planar arm. For realistic robots in 3D, the same pattern applies, but \( \mathbf{J} \) is a full 6 × \( n \) matrix, often obtained from a robotics library:

• Python: roboticstoolbox, modern_robotics
• C++: Orocos KDL (orocos_kdl)
• Java: general linear algebra via EJML (no de facto standard robotics library)
• MATLAB: Robotics System Toolbox (rigidBodyTree, geometricJacobian)
• Mathematica: symbolic and numeric matrix computations

6.1 Python (NumPy, with note on robotics libraries)

import numpy as np

def jacobian_2r(q, l1, l2):
    """
    Planar 2R translational Jacobian J_v(q) in the plane.
    q : array-like [q1, q2]
    l1, l2 : link lengths
    """
    q1, q2 = q
    s1 = np.sin(q1)
    c1 = np.cos(q1)
    s12 = np.sin(q1 + q2)
    c12 = np.cos(q1 + q2)

    J = np.array([
        [-l1 * s1 - l2 * s12, -l2 * s12],
        [ l1 * c1 + l2 * c12,  l2 * c12]
    ])
    return J

def torque_from_force(q, f, l1=1.0, l2=1.0):
    """
    Compute joint torques tau = J_v(q)^T f for planar 2R arm.
    f : np.array shape (2,) = [Fx, Fy]
    """
    J = jacobian_2r(q, l1, l2)
    tau = J.T @ f
    return tau

if __name__ == "__main__":
    # Example: l1=l2=1, q=[0,0], force downward Fy = -10
    q = np.array([0.0, 0.0])
    f = np.array([0.0, -10.0])
    tau = torque_from_force(q, f, l1=1.0, l2=1.0)
    print("Joint torques:", tau)

    # With roboticstoolbox, for a general robot one could do:
    # from roboticstoolbox import DHRobot, RevoluteDH
    # robot = DHRobot([...])  # define links
    # J_full = robot.jacob0(q)    # 6 x n Jacobian in base frame
    # F6 = np.array([Nx, Ny, Nz, Fx, Fy, Fz])
    # tau_full = J_full.T @ F6
      

6.2 C++ (Eigen + note on Orocos KDL)

#include <iostream>
#include <Eigen/Dense>

// Planar 2R translational Jacobian
Eigen::Matrix2d jacobian2R(double q1, double q2, double l1, double l2) {
    double s1  = std::sin(q1);
    double c1  = std::cos(q1);
    double s12 = std::sin(q1 + q2);
    double c12 = std::cos(q1 + q2);

    Eigen::Matrix2d J;
    J(0,0) = -l1 * s1 - l2 * s12;
    J(0,1) = -l2 * s12;
    J(1,0) =  l1 * c1 + l2 * c12;
    J(1,1) =  l2 * c12;
    return J;
}

Eigen::Vector2d torqueFromForce(
    double q1, double q2,
    double Fx, double Fy,
    double l1, double l2)
{
    Eigen::Matrix2d J = jacobian2R(q1, q2, l1, l2);
    Eigen::Vector2d f(Fx, Fy);
    Eigen::Vector2d tau = J.transpose() * f;
    return tau;
}

int main() {
    double l1 = 1.0, l2 = 1.0;
    double q1 = 0.0, q2 = 0.0;
    double Fx = 0.0, Fy = -10.0;

    Eigen::Vector2d tau = torqueFromForce(q1, q2, Fx, Fy, l1, l2);
    std::cout << "tau = " << tau.transpose() << std::endl;

    // In Orocos KDL, a general 6 x n Jacobian J can be computed for a kinematic chain.
    // Then one directly uses: tau = J.data.transpose() * F;  where F is a 6D wrench.
    return 0;
}
      

6.3 Java (EJML for Linear Algebra)

import org.ejml.simple.SimpleMatrix;

public class JacobianTranspose2R {

    public static SimpleMatrix jacobian2R(double q1, double q2,
                                          double l1, double l2) {
        double s1  = Math.sin(q1);
        double c1  = Math.cos(q1);
        double s12 = Math.sin(q1 + q2);
        double c12 = Math.cos(q1 + q2);

        double[][] data = new double[][] {
            { -l1 * s1 - l2 * s12, -l2 * s12 },
            {  l1 * c1 + l2 * c12,  l2 * c12 }
        };
        return new SimpleMatrix(data);
    }

    public static SimpleMatrix torqueFromForce(
            double q1, double q2,
            double Fx, double Fy,
            double l1, double l2) {

        SimpleMatrix J = jacobian2R(q1, q2, l1, l2);
        SimpleMatrix f = new SimpleMatrix(2, 1, true, new double[] {Fx, Fy});
        return J.transpose().mult(f);
    }

    public static void main(String[] args) {
        double l1 = 1.0, l2 = 1.0;
        double q1 = 0.0, q2 = 0.0;
        double Fx = 0.0, Fy = -10.0;

        SimpleMatrix tau = torqueFromForce(q1, q2, Fx, Fy, l1, l2);
        System.out.println("tau = ");
        tau.print();
    }
}
      

In Java, robotics-specific functionality is often built on top of such linear algebra libraries (e.g., EJML, Apache Commons Math), since there is no universally adopted robotics library analogous to Orocos KDL or MATLAB's Robotics System Toolbox.

6.4 MATLAB / Simulink

function tau = torqueFromForce2R(q, f, l1, l2)
% torqueFromForce2R - Joint torques from end-effector force for a planar 2R arm.
% q  : [q1; q2]
% f  : [Fx; Fy]
% l1, l2 : link lengths

q1 = q(1); q2 = q(2);
Fx = f(1); Fy = f(2);

s1  = sin(q1);
c1  = cos(q1);
s12 = sin(q1 + q2);
c12 = cos(q1 + q2);

J = [ -l1 * s1 - l2 * s12, -l2 * s12;
       l1 * c1 + l2 * c12,  l2 * c12 ];

tau = J' * [Fx; Fy];
end

% Example usage (script):
l1 = 1; l2 = 1;
q = [0; 0];
f = [0; -10];
tau_example = torqueFromForce2R(q, f, l1, l2)
      

In MATLAB's Robotics System Toolbox for a general 3D manipulator:

% Assume 'robot' is a rigidBodyTree and 'endEffector' its end-effector name.
q = rand(robot.NumBodies, 1);   % joint configuration
J = geometricJacobian(robot, q', endEffector);  % 6 x n Jacobian
F = [Nx; Ny; Nz; Fx; Fy; Fz];                    % 6 x 1 wrench in base frame
tau = J' * F;                                    % n x 1 joint torques
      

In Simulink, the MATLAB function torqueFromForce2R can be wrapped in a MATLAB Function block. Inputs are joint angles q and force f, and the block outputs tau, which can be used in a static balance computation.

6.5 Wolfram Mathematica

(* Planar 2R Jacobian and torque mapping *)
Clear[J2R, tauFromForce2R]

J2R[{q1_, q2_}, l1_, l2_] := Module[
  {s1, c1, s12, c12},
  s1  = Sin[q1];
  c1  = Cos[q1];
  s12 = Sin[q1 + q2];
  c12 = Cos[q1 + q2];

  { {-l1*s1 - l2*s12, -l2*s12},
   { l1*c1 + l2*c12,  l2*c12} }
];

tauFromForce2R[{q1_, q2_}, {Fx_, Fy_}, l1_, l2_] := Module[
  {J, f},
  J = J2R[{q1, q2}, l1, l2];
  f = { {Fx}, {Fy} };
  Transpose[J].f // Simplify
];

(* Example: l1=l2=1, q1=q2=0, downward force Fy=-10 *)
tauExample = tauFromForce2R[{0, 0}, {0, -10}, 1, 1]
      

Mathematica is particularly convenient for symbolic exploration of Jacobians and torque mappings, allowing closed-form expressions for more complex manipulators and for analyzing singularities symbolically.

This lesson established the Jacobian transpose relation \( \boldsymbol{\tau} = \mathbf{J}^\top \mathbf{F} \) as the fundamental static mapping between end-effector wrenches and joint torques. Starting from the virtual work principle, we derived the mapping, proved its power consistency, and analyzed its geometric implications including internal torques and force manipulability ellipsoids. A planar 2R example illustrated explicit expressions and numeric evaluation. Finally, we implemented the mapping in Python, C++, Java, MATLAB/Simulink, and Mathematica, connecting the theory to practical computation on real manipulators. This mapping is a building block for later topics such as load capacity, static equilibrium, and eventually force-based control.