In three-dimensional rigid-body mechanics, an external load applied to a rigid body is described by a force \( \mathbf{f} \in \mathbb{R}^3 \) acting at some point \( \mathbf{r} \in \mathbb{R}^3 \). Relative to a chosen origin (e.g., a frame attached to the robot base), the corresponding moment (or torque vector) is

\[ \mathbf{m}_O = \mathbf{r} \times \mathbf{f} \in \mathbb{R}^3. \]

Together, the pair \( (\mathbf{f}, \mathbf{m}_O) \) is called a wrench. At the level of coordinates, we often write the Plücker coordinates of a wrench as a 6-dimensional vector

\[ \mathbf{w}_O = \begin{bmatrix} \mathbf{f} \\[2mm] \mathbf{m}_O \end{bmatrix} \in \mathbb{R}^6. \]

The subscript \(O\) emphasizes that the moment depends on the choice of origin, while the physical load (the line of action of the force and the overall twisting effect on the body) does not.

In later lessons, joint torques will be obtained from end-effector wrenches via the Jacobian transpose. For now, we focus purely on how wrenches are represented and transformed on the configuration space \( \mathrm{SE}(3) \).

flowchart TD
  A["External load: force f at point r"] --> B["Compute moment m_O = r x f about chosen origin"]
  B --> C["Form wrench w_O = [f; m_O]"]
  C --> D["Change reference frame (rotation, translation) in SE(3)"]
  D --> E["Transform wrench coordinates via 6x6 matrix"]
  E --> F["Use wrench in statics: sum of wrenches = 0 for equilibrium"]
        

Consider a rigid body with a force \( \mathbf{f} \) applied at a point \(Q\). Let \(O\) and \(O'\) be two choices of origins. Denote:

• \( \mathbf{r}_O \): position of \(Q\) with respect to origin \(O\),
• \( \mathbf{r}_{O'} \): position of \(Q\) with respect to origin \(O'\),
• \( \mathbf{p} \): vector from \(O\) to \(O'\) (expressed in the same frame).

Then the position vectors satisfy

\[ \mathbf{r}_O = \mathbf{p} + \mathbf{r}_{O'}. \]

The moment of \(\mathbf{f}\) about origin \(O\) is

\[ \mathbf{m}_O = \mathbf{r}_O \times \mathbf{f}. \]

The moment about \(O'\) is

\[ \mathbf{m}_{O'} = \mathbf{r}_{O'} \times \mathbf{f}. \]

Substituting \( \mathbf{r}_{O'} = \mathbf{r}_O - \mathbf{p} \) gives

\[ \mathbf{m}_{O'} = (\mathbf{r}_O - \mathbf{p}) \times \mathbf{f} = \mathbf{r}_O \times \mathbf{f} - \mathbf{p} \times \mathbf{f} = \mathbf{m}_O - \mathbf{p} \times \mathbf{f}. \]

Hence the moment shift formula is

\[ \boxed{ \mathbf{m}_{O'} = \mathbf{m}_O - \mathbf{p} \times \mathbf{f} }. \]

In terms of wrenches, if we define \( \mathbf{w}_O = [\mathbf{f}^\top \; \mathbf{m}_O^\top]^\top \) and similarly for \(O'\), then the same physical load has different 6D coordinates:

\[ \mathbf{w}_{O'} = \begin{bmatrix} \mathbf{f} \\[2mm] \mathbf{m}_O - \mathbf{p} \times \mathbf{f} \end{bmatrix}. \]

This already shows that a wrench is not just a 6D vector: many different pairs \( (\mathbf{f}, \mathbf{m}_O) \) represent the same physical screw, differing only by the reference point.

Geometrically, a nonzero force vector \( \mathbf{f} \) defines an oriented line in space: its line of action. Any point \(Q\) on this line may be used as the reference point. We can choose \(\mathbf{r}_O\) such that

\[ \mathbf{m}_O = \mathbf{r}_O \times \mathbf{f} \]

and the pair \( (\mathbf{f}, \mathbf{m}_O) \) are then the Plücker coordinates of the line. If we move to another point on the same line, the force is unchanged but the moment shifts by a vector parallel to \( \mathbf{f} \).

In terms of linear algebra, introduce the skew-symmetric matrix associated with \( \mathbf{p} = [p_1, p_2, p_3]^\top \):

\[ \widehat{\mathbf{p}} = \begin{bmatrix} 0 & -p_3 & p_2 \\ p_3 & 0 & -p_1 \\ -p_2 & p_1 & 0 \end{bmatrix}, \quad\text{so that}\quad \widehat{\mathbf{p}}\,\mathbf{f} = \mathbf{p} \times \mathbf{f}. \]

The shift in Plücker coordinates when changing from origin \(O\) to \(O'\) is

\[ \mathbf{w}_{O'} = \begin{bmatrix} \mathbf{f} \\[2mm] \mathbf{m}_{O'} \end{bmatrix} = \begin{bmatrix} \mathbf{f} \\[2mm] \mathbf{m}_O - \mathbf{p} \times \mathbf{f} \end{bmatrix} = \begin{bmatrix} \mathbf{I}_3 & \mathbf{0} \\ -\widehat{\mathbf{p}} & \mathbf{I}_3 \end{bmatrix} \begin{bmatrix} \mathbf{f} \\[2mm] \mathbf{m}_O \end{bmatrix}. \]

The \(6 \times 6\) matrix above is a static shift transform. In SE(3)-based robotics, we typically combine such shifts with rotations when moving between frames.

A special case is a pure couple, for which \( \mathbf{f} = \mathbf{0} \) and \( \mathbf{m}_O \neq \mathbf{0} \). This wrench is independent of the choice of origin:

\[ \mathbf{m}_{O'} = \mathbf{m}_O - \mathbf{p} \times \mathbf{0} = \mathbf{m}_O. \]

Pure couples model ideal joint torques or actuator moments that do not result from a net force applied at any specific point in space.

The configuration of a rigid body in space is represented by an element of \( \mathrm{SE}(3) \):

\[ \mathbf{g} = \begin{bmatrix} \mathbf{R} & \mathbf{p} \\ \mathbf{0}^\top & 1 \end{bmatrix}, \quad \mathbf{R} \in \mathrm{SO}(3),\ \mathbf{p} \in \mathbb{R}^3. \]

The twist of the body is an element of the Lie algebra \( \mathfrak{se}(3) \), often represented by a 6D vector \( \mathbf{v} = [\boldsymbol{\omega}^\top\; \mathbf{v}_\mathrm{lin}^\top]^\top \), where \( \boldsymbol{\omega} \) is the angular velocity and \( \mathbf{v}_\mathrm{lin} \) is the linear velocity at the origin of the frame.

The adjoint representation of \( \mathrm{SE}(3) \) acts on twists via a \(6 \times 6\) matrix:

\[ \operatorname{Ad}_{\mathbf{g}} = \begin{bmatrix} \mathbf{R} & \mathbf{0} \\ \widehat{\mathbf{p}}\,\mathbf{R} & \mathbf{R} \end{bmatrix}, \quad \mathbf{v}_A = \operatorname{Ad}_{\mathbf{g}}\,\mathbf{v}_B, \]

where \( \mathbf{v}_B \) is the twist expressed in frame \(B\), and \( \mathbf{v}_A \) is the same physical twist expressed in frame \(A\), with \( \mathbf{g} \) the transform from \(B\) to \(A\).

A wrench is dual to a twist in the sense of virtual work. For a twist \( \mathbf{v} = [\boldsymbol{\omega}^\top\; \mathbf{v}_\mathrm{lin}^\top]^\top \) and a wrench \( \mathbf{w} = [\mathbf{f}^\top\; \mathbf{m}^\top]^\top \), the instantaneous power is

\[ P = \mathbf{w}^\top \mathbf{v} = \mathbf{f}^\top \mathbf{v}_\mathrm{lin} + \mathbf{m}^\top \boldsymbol{\omega}. \]

This pairing defines a bilinear form between \( \mathfrak{se}(3) \) and its dual \( \mathfrak{se}(3)^* \). Under a change of frame, the physical power must be invariant, even though the coordinates of \(\mathbf{w}\) and \(\mathbf{v}\) change.

Suppose the twist coordinates transform as \( \mathbf{v}_A = \operatorname{Ad}_{\mathbf{g}} \mathbf{v}_B \). Enforcing invariance of power,

\[ \mathbf{w}_A^\top \mathbf{v}_A = \mathbf{w}_B^\top \mathbf{v}_B \quad\text{for all twists } \mathbf{v}_B, \]

leads to

\[ \mathbf{w}_B^\top \mathbf{v}_B = \mathbf{w}_A^\top \operatorname{Ad}_{\mathbf{g}} \mathbf{v}_B = (\operatorname{Ad}_{\mathbf{g}}^\top \mathbf{w}_A)^\top \mathbf{v}_B, \]

hence, for all \(\mathbf{v}_B\),

\[ \boxed{\mathbf{w}_B = \operatorname{Ad}_{\mathbf{g}}^\top \mathbf{w}_A.} \]

This is the dual adjoint action: wrenches transform via the transpose of the adjoint matrix of twists. Equivalently, one can write \( \mathbf{w}_A = \operatorname{Ad}_{\mathbf{g}}^{-\top} \mathbf{w}_B \) when the direction of the transform is inverted.

In practical robotics, it is common to use the more explicit component-wise formulas between frames \(A\) and \(B\) with transform \( \mathbf{g} = [\mathbf{R}, \mathbf{p}; \mathbf{0}^\top, 1] \) (position of the origin of \(B\) expressed in \(A\)):

\[ \begin{aligned} \mathbf{f}_A &= \mathbf{R}\,\mathbf{f}_B, \\[1mm] \mathbf{m}_A &= \mathbf{p} \times \mathbf{f}_A + \mathbf{R}\,\mathbf{m}_B. \end{aligned} \]

In 6D matrix form,

\[ \begin{bmatrix} \mathbf{f}_A \\[2mm] \mathbf{m}_A \end{bmatrix} = \underbrace{ \begin{bmatrix} \mathbf{R} & \mathbf{0} \\ \widehat{\mathbf{p}}\,\mathbf{R} & \mathbf{R} \end{bmatrix} }_{\displaystyle \operatorname{Ad}_{\mathbf{g}}^*} \begin{bmatrix} \mathbf{f}_B \\[2mm] \mathbf{m}_B \end{bmatrix}, \]

where \( \operatorname{Ad}_{\mathbf{g}}^* \) is sometimes called the force transformation matrix. It is algebraically related to \( \operatorname{Ad}_{\mathbf{g}} \) by transposition and inversion, but in implementation it is usually constructed directly from \( \mathbf{R} \) and \(\mathbf{p}\).

Consider a force of magnitude \(F\) acting along the positive \(z\)-axis of frame \(B\), applied at the origin of \(B\):

\[ \mathbf{f}_B = \begin{bmatrix} 0 \\ 0 \\ F \end{bmatrix}, \quad \mathbf{m}_B = \begin{bmatrix} 0 \\ 0 \\ 0 \end{bmatrix}. \]

Frame \(B\) is located relative to frame \(A\) by a rotation of \(90^\circ\) around the \(y\)-axis and a translation \( \mathbf{p} = [a, 0, 0]^\top \) along the \(x\)-axis of frame \(A\):

\[ \mathbf{R} = \begin{bmatrix} 0 & 0 & 1 \\ 0 & 1 & 0 \\ -1 & 0 & 0 \end{bmatrix}, \quad \mathbf{p} = \begin{bmatrix} a \\ 0 \\ 0 \end{bmatrix}. \]

The force in frame \(A\) is

\[ \mathbf{f}_A = \mathbf{R}\,\mathbf{f}_B = \begin{bmatrix} 0 \\ 0 \\ F \end{bmatrix}, \]

so numerically it still points along the \(z\)-axis of \(A\). The moment in frame \(A\) is

\[ \mathbf{m}_A = \mathbf{p} \times \mathbf{f}_A + \mathbf{R}\,\mathbf{m}_B = \mathbf{p} \times \mathbf{f}_A = \begin{bmatrix} a \\ 0 \\ 0 \end{bmatrix} \times \begin{bmatrix} 0 \\ 0 \\ F \end{bmatrix} = \begin{bmatrix} 0 \\ -aF \\ 0 \end{bmatrix}. \]

Thus, relative to frame \(A\), the wrench is

\[ \mathbf{w}_A = \begin{bmatrix} \mathbf{f}_A \\[1mm] \mathbf{m}_A \end{bmatrix} = \begin{bmatrix} 0 \\ 0 \\ F \\[1mm] 0 \\ -aF \\ 0 \end{bmatrix}. \]

If we consider a twist corresponding to a unit translational velocity along the \(z\)-axis of frame \(A\), its coordinates in frame \(A\) are

\[ \mathbf{v}_A = \begin{bmatrix} \boldsymbol{\omega}_A \\[1mm] \mathbf{v}_{\mathrm{lin},A} \end{bmatrix} = \begin{bmatrix} 0 \\ 0 \\ 0 \\[1mm] 0 \\ 0 \\ 1 \end{bmatrix}. \]

The instantaneous power is then

\[ P = \mathbf{w}_A^\top \mathbf{v}_A = \mathbf{f}_A^\top \mathbf{v}_{\mathrm{lin},A} = F. \]

Transforming both the twist and the wrench to frame \(B\) would yield the same power, verifying the dual transformation law in practice.

In Python, we can use numpy to implement the skew-symmetric matrix and the 6D wrench transformation based on \( \operatorname{Ad}_{\mathbf{g}}^* \).

import numpy as np

def hat(p):
    """
    Skew-symmetric matrix for cross product:
    hat(p) @ f == np.cross(p, f)
    """
    px, py, pz = p
    return np.array([
        [0.0, -pz,  py],
        [pz,  0.0, -px],
        [-py, px,  0.0]
    ], dtype=float)

def wrench_transform(R, p, w_B):
    """
    Transform wrench from frame B to frame A, given:
    - R: 3x3 rotation matrix from B to A
    - p: 3x1 translation vector (origin of B expressed in A)
    - w_B: 6x1 wrench in frame B, [f_B; m_B]
    Returns w_A: 6x1 wrench in frame A, [f_A; m_A]
    """
    R = np.asarray(R, dtype=float).reshape(3, 3)
    p = np.asarray(p, dtype=float).reshape(3,)
    w_B = np.asarray(w_B, dtype=float).reshape(6,)

    f_B = w_B[0:3]
    m_B = w_B[3:6]

    # Force transformation
    f_A = R @ f_B

    # Moment transformation
    m_A = hat(p) @ f_A + R @ m_B

    w_A = np.concatenate((f_A, m_A))
    return w_A

if __name__ == "__main__":
    # Example: same configuration as Section 5
    F = 10.0
    f_B = np.array([0.0, 0.0, F])
    m_B = np.zeros(3)
    w_B = np.concatenate((f_B, m_B))

    R = np.array([
        [0.0, 0.0, 1.0],
        [0.0, 1.0, 0.0],
        [-1.0, 0.0, 0.0]
    ])
    p = np.array([0.5, 0.0, 0.0])  # 0.5 m along x_A

    w_A = wrench_transform(R, p, w_B)
    print("Wrench in A:", w_A)
      

This function will later be used when mapping external contact wrenches (e.g., from end-effector frame) into a common base frame for statics and dynamics.

In C++, the Eigen library is a convenient choice for linear algebra in robotics. The following example shows a minimal wrench transformation function using Eigen::Matrix3d and Eigen::Matrix<double, 6, 1>.

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

using Wrench6d = Eigen::Matrix<double, 6, 1>;

Eigen::Matrix3d hat(const Eigen::Vector3d& p) {
    Eigen::Matrix3d P;
    P <<   0.0,    -p.z(),  p.y(),
            p.z(),   0.0,   -p.x(),
           -p.y(),   p.x(),  0.0;
    return P;
}

Wrench6d transformWrench(
    const Eigen::Matrix3d& R,
    const Eigen::Vector3d& p,
    const Wrench6d& w_B)
{
    Eigen::Vector3d f_B = w_B.segment<3>(0);
    Eigen::Vector3d m_B = w_B.segment<3>(3);

    Eigen::Vector3d f_A = R * f_B;
    Eigen::Vector3d m_A = hat(p) * f_A + R * m_B;

    Wrench6d w_A;
    w_A.segment<3>(0) = f_A;
    w_A.segment<3>(3) = m_A;
    return w_A;
}

int main() {
    Eigen::Matrix3d R;
    R << 0.0, 0.0, 1.0,
          0.0, 1.0, 0.0,
         -1.0, 0.0, 0.0;
    Eigen::Vector3d p(0.5, 0.0, 0.0);

    Wrench6d w_B;
    w_B << 0.0, 0.0, 10.0,  // force
            0.0, 0.0,  0.0;  // moment

    Wrench6d w_A = transformWrench(R, p, w_B);
    std::cout << "w_A = \n" << w_A << std::endl;
    return 0;
}
      

This pattern (using a 6D vector for wrench and a 3D rotation/translation pair) is standard in many C++ robotics toolboxes and can be extended to accumulate multiple contact wrenches.

In Java, there is no built-in matrix library, but we can either use a third-party library (e.g., EJML) or stay with small fixed-size arrays for basic operations. Below is an array-based implementation of the wrench transformation:

public class WrenchTransform {

    // Compute p x f
    public static double[] cross(double[] p, double[] f) {
        return new double[] {
            p[1] * f[2] - p[2] * f[1],
            p[2] * f[0] - p[0] * f[2],
            p[0] * f[1] - p[1] * f[0]
        };
    }

    // Multiply 3x3 matrix R by 3x1 vector v
    public static double[] matVec(double[][] R, double[] v) {
        return new double[] {
            R[0][0]*v[0] + R[0][1]*v[1] + R[0][2]*v[2],
            R[1][0]*v[0] + R[1][1]*v[1] + R[1][2]*v[2],
            R[2][0]*v[0] + R[2][1]*v[1] + R[2][2]*v[2]
        };
    }

    public static double[] transformWrench(double[][] R, double[] p, double[] wB) {
        // wB = [fB(0:2); mB(3:5)]
        double[] fB = new double[] { wB[0], wB[1], wB[2] };
        double[] mB = new double[] { wB[3], wB[4], wB[5] };

        double[] fA = matVec(R, fB);
        double[] px_fA = cross(p, fA);
        double[] mA_rot = matVec(R, mB);

        double[] mA = new double[] {
            px_fA[0] + mA_rot[0],
            px_fA[1] + mA_rot[1],
            px_fA[2] + mA_rot[2]
        };

        return new double[] { fA[0], fA[1], fA[2], mA[0], mA[1], mA[2] };
    }

    public static void main(String[] args) {
        double[][] R = {
            {0.0, 0.0, 1.0},
            {0.0, 1.0, 0.0},
            {-1.0, 0.0, 0.0}
        };
        double[] p = {0.5, 0.0, 0.0};
        double[] wB = {0.0, 0.0, 10.0, 0.0, 0.0, 0.0};

        double[] wA = transformWrench(R, p, wB);
        System.out.println("wA = ");
        for (double x : wA) {
            System.out.println(x);
        }
    }
}
      

This style is sufficient for embedding wrench calculations in Java-based simulation or visualization tools where only a small number of rigid bodies are involved.

MATLAB is widely used in control and robotics curricula. The corresponding implementation of skew-symmetric matrices and wrench transformations follows the same formulas:

function wA = transformWrench(R, p, wB)
%TRANSFORMWRENCH Transform wrench from frame B to frame A.
%   R  : 3x3 rotation matrix from B to A
%   p  : 3x1 translation (origin of B expressed in frame A)
%   wB : 6x1 wrench [fB; mB]
%   wA : 6x1 wrench [fA; mA]

    fB = wB(1:3);
    mB = wB(4:6);

    fA = R * fB;
    mA = hat(p) * fA + R * mB;

    wA = [fA; mA];
end

function P = hat(p)
%HAT Skew-symmetric matrix for cross product: P*f == cross(p, f)
    P = [    0, -p(3),  p(2);
          p(3),     0, -p(1);
         -p(2),  p(1),     0];
end
      

In Simulink, a typical pattern is:

• Use three Inport blocks for \( \mathbf{R} \), \( \mathbf{p} \), and \( \mathbf{w}_B \).
• Insert a MATLAB Function block containing the transformWrench function above.
• Connect outputs to downstream blocks that implement static equilibrium or joint torque computations (to be developed in later lessons).

This modular design allows wrenches from multiple contacts to be transformed and summed before being used for control or analysis.

In Wolfram Mathematica, we can represent wrenches as length-6 lists and implement the transformation with symbolic or numeric matrices, which is convenient for analytic derivations and simplifications.

Clear[hat, transformWrench];

hat[p_List] /; Length[p] == 3 := { {0, -p[[3]], p[[2]]},
                                  {p[[3]], 0, -p[[1]]},
                                  {-p[[2]], p[[1]], 0} };

transformWrench[R_?MatrixQ, p_List, wB_List] := Module[
  {fB, mB, fA, mA},
  fB = Take[wB, 3];
  mB = Take[wB, -3];
  fA = R . fB;
  mA = hat[p] . fA + R . mB;
  Join[fA, mA]
];

(* Example usage *)
R = { {0, 0, 1},
     {0, 1, 0},
     {-1, 0, 0} };
p = {0.5, 0, 0};
wB = {0, 0, 10, 0, 0, 0};

wA = transformWrench[R, p, wB] // Simplify
      

Because Mathematica can manipulate symbols, it is a powerful environment for proving identities such as \( \mathbf{w}_B = \operatorname{Ad}_{\mathbf{g}}^\top \mathbf{w}_A \) directly from the definitions of \( \operatorname{Ad}_{\mathbf{g}} \) and the cross product matrix.

In this lesson we formalized the notion of a wrench as a combined representation of force and moment in 3D space and showed how its coordinates depend on the choice of origin and reference frame. Using Plücker coordinates, we derived the moment shift formula and expressed wrenches as 6D vectors. We then embedded these constructions into the Lie group \( \mathrm{SE}(3) \), introducing the adjoint action on twists and the dual adjoint transformation for wrenches, derived from virtual work invariance. Finally, we developed concrete implementations in Python, C++, Java, MATLAB/Simulink, and Wolfram Mathematica that will be reused in later lessons for static equilibrium analysis and wrench transmission through robot kinematic chains.