For an \( n \)-DOF manipulator with configuration \( \mathbf{q}\in\mathbb{R}^n \) and task-space coordinates \( \mathbf{x}\in\mathbb{R}^m \), the differential kinematics relation around a configuration \( \mathbf{q}_0 \) is

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

where \( \mathbf{J}(\mathbf{q}_0)\in\mathbb{R}^{m\times n} \) is the Jacobian evaluated at \( \mathbf{q}_0 \). Small joint errors \( \delta \mathbf{q} \) (sensor noise, quantization, calibration error) are mapped to task-space errors \( \delta \mathbf{x} \). A key question is:

How much can \( \delta \mathbf{x} \) amplify relative to \( \delta \mathbf{q} \)?

Using a vector norm \( \|\cdot\| \), we can bound \( \|\delta \mathbf{x}\| \) by the induced matrix norm of \( \mathbf{J} \):

\[ \|\delta \mathbf{x}\| \le \|\mathbf{J}(\mathbf{q}_0)\|\,\|\delta \mathbf{q}\|. \]

When solving the inverse problem (local IK) \( \mathbf{J}(\mathbf{q}_0)\,\delta \mathbf{q} = \delta \mathbf{x} \), the condition number of the Jacobian determines how sensitive the solution \( \delta \mathbf{q} \) is to perturbations in \( \delta \mathbf{x} \) and/or perturbations in \( \mathbf{J} \) itself.

flowchart TD
  Q["Joint space: q"] --> JAC["Jacobian J(q)"]
  JAC --> DX["Forward map: delta_x = J delta_q"]
  DX --> AMP["Amplification: ||delta_x|| / ||delta_q||"]
  JAC --> INV["Inverse map: solve J delta_q = delta_x"]
  INV --> KAP["Condition number kappa(J)"]
  KAP --> SENS["Sensitivity of IK and numerical stability"]
        

Let \( A\in\mathbb{R}^{n\times n} \) be nonsingular. A vector norm \( \|\cdot\| \) induces a matrix norm

\[ \|A\| = \max_{\mathbf{x}\neq\mathbf{0}} \frac{\|A\mathbf{x}\|}{\|\mathbf{x}\|}. \]

The condition number of \( A \) with respect to this norm is

\[ \kappa(A) = \|A\|\;\|A^{-1}\|. \]

Consider the linear system \( A\mathbf{x}=\mathbf{b} \), with exact solution \( \mathbf{x} \). If the right-hand side is perturbed to \( \mathbf{b}+\delta \mathbf{b} \), the new solution \( \mathbf{x}+\delta \mathbf{x} \) satisfies \( A(\mathbf{x}+\delta \mathbf{x})=\mathbf{b}+\delta\mathbf{b} \). Subtracting,

\[ A\,\delta \mathbf{x} = \delta \mathbf{b} \quad\Rightarrow\quad \delta \mathbf{x} = A^{-1}\delta \mathbf{b}. \]

Applying the induced norm and using submultiplicativity,

\[ \|\delta \mathbf{x}\| \le \|A^{-1}\|\,\|\delta \mathbf{b}\|. \]

To relate absolute to relative errors, note that \( \mathbf{b}=A\mathbf{x} \) implies

\[ \|\mathbf{b}\| = \|A\mathbf{x}\|\le \|A\|\;\|\mathbf{x}\| \quad\Rightarrow\quad \frac{\|\mathbf{x}\|}{\|\mathbf{b}\|} \ge \frac{1}{\|A\|}. \]

Combining,

\[ \frac{\|\delta \mathbf{x}\|}{\|\mathbf{x}\|} \le \|A^{-1}\|\;\|\delta\mathbf{b}\|\;\frac{1}{\|\mathbf{x}\|} \le \|A^{-1}\|\;\|A\|\;\frac{\|\delta\mathbf{b}\|}{\|\mathbf{b}\|} = \kappa(A)\,\frac{\|\delta\mathbf{b}\|}{\|\mathbf{b}\|}. \]

Thus the relative solution error is (to first order) bounded by \( \kappa(A) \) times the relative data error. In robotics, the analogous role is played by the Jacobian or local linear ization of kinematic mappings.

For the 2-norm, the condition number simplifies via the singular values: if \( A \) has singular values \( \sigma_1\ge\dots\ge\sigma_n>0 \), then

\[ \kappa_2(A)=\frac{\sigma_1}{\sigma_n}. \]

When \( \kappa_2(A) \) is large, the mapping is highly anisotropic: some input directions are greatly amplified and others are strongly attenuated.

Robot Jacobians \( \mathbf{J}(\mathbf{q})\in\mathbb{R}^{m\times n} \) are often non-square: \( m<n \) (redundant) or \( m>n \) (underactuated). The 2-norm induced by the Euclidean norm is still

\[ \|\mathbf{J}\|_2 = \max_{\mathbf{v}\neq\mathbf{0}} \frac{\|\mathbf{J}\mathbf{v}\|_2}{\|\mathbf{v}\|_2}. \]

Using the singular value decomposition (SVD) \( \mathbf{J}= \mathbf{U}\,\boldsymbol{\Sigma}\,\mathbf{V}^\top \) with singular values \( \sigma_1\ge\dots\ge\sigma_r>0 \) (rank \( r \)), one has

\[ \|\mathbf{J}\|_2 = \sigma_1. \]

For full-row-rank or full-column-rank Jacobians, a widely used kinematic condition number (Yoshikawa-type) is

\[ \kappa(\mathbf{J}) = \frac{\sigma_{\max}(\mathbf{J})} {\sigma_{\min}(\mathbf{J})}, \]

where \( \sigma_{\min}(\mathbf{J}) \) is the smallest nonzero singular value. A small \( \sigma_{\min} \) indicates proximity to a singularity; indeed \( \sigma_{\min}\to 0 \) implies \( \kappa(\mathbf{J})\to\infty \). This condition number is tightly connected to the manipulability ellipsoid discussed in Lesson 2.

For local IK in the redundant case, one typically solves \( \mathbf{J}\,\delta\mathbf{q} \approx \delta\mathbf{x} \) via the Moore–Penrose pseudoinverse \( \mathbf{J}^+ = \mathbf{V}\,\boldsymbol{\Sigma}^+\,\mathbf{U}^\top \), giving the minimum-norm solution

\[ \delta\mathbf{q} = \mathbf{J}^+\,\delta\mathbf{x}. \]

The sensitivity of this solution is governed by the same singular values: small \( \sigma_{\min} \) produce large joint motions for modest task-space changes.

For forward differential kinematics, from \( \delta\mathbf{x}=\mathbf{J}\delta\mathbf{q} \), the worst-case amplification factor of joint errors is

\[ \max_{\delta\mathbf{q}\neq\mathbf{0}} \frac{\|\delta\mathbf{x}\|_2}{\|\delta\mathbf{q}\|_2} = \|\mathbf{J}\|_2 = \sigma_{\max}(\mathbf{J}). \]

Conversely, in the square, nonsingular case \( m=n \), for inverse differential kinematics \( \delta\mathbf{q} = \mathbf{J}^{-1}\delta\mathbf{x} \),

\[ \frac{\|\delta\mathbf{q}\|_2}{\|\delta\mathbf{x}\|_2} \le \|\mathbf{J}^{-1}\|_2 = \frac{1}{\sigma_{\min}(\mathbf{J})}. \]

When both forward and inverse effects are relevant, e.g., when \( \delta\mathbf{x} \) is itself due to physical perturbations of \( \mathbf{q} \) and model errors in \( \mathbf{J} \), the condition number \( \kappa_2(\mathbf{J}) = \sigma_{\max}/\sigma_{\min} \) bounds the relative error amplification in joint solutions to task-space perturbations (under suitable regularity assumptions).

Special case: diagonal Jacobian. Suppose \( \mathbf{J}=\mathrm{diag}(a,b) \) with \( a,b>0 \). Then singular values are \( \sigma_1 = \max\{a,b\},\; \sigma_2=\min\{a,b\} \) and

\[ \kappa_2(\mathbf{J}) = \frac{\max\{a,b\}}{\min\{a,b\}}. \]

This shows explicitly that when the mapping is isotropic (\( a=b \)), \( \kappa_2(\mathbf{J})=1 \), while strong anisotropy \( a\gg b \) yields a large condition number and poor numerical robustness.

flowchart TD
  A["Compute J(q)"] --> B["SVD: J = U Sigma V^T"]
  B --> C["Singular values: sigma_max, sigma_min"]
  C --> D["Condition number kappa = sigma_max / sigma_min"]
  D --> E["Interpretation: near 1 = isotropic"]
  D --> F["Large kappa = near singular, high sensitivity"]
        

A subtlety in robotic Jacobians is that they mix translational and rotational velocities, which have different physical units. A typical spatial Jacobian has the form \( \mathbf{J} = \begin{bmatrix}\mathbf{J}_\omega \\[0.2em] \mathbf{J}_v\end{bmatrix} \), where \( \mathbf{J}_\omega \) maps joint velocities to angular velocity and \( \mathbf{J}_v \) maps to linear velocity.

To obtain a meaningful condition number, one often introduces weighting matrices \( W_x \) and \( W_q \) defining a task-space and joint-space metric:

\[ \tilde{\mathbf{J}} = W_x\,\mathbf{J}\,W_q^{-1}. \]

For example, \( W_x \) can scale angular components by a characteristic length \( \ell \), turning radians into equivalent meters, and \( W_q \) can normalize joints by their limits. The condition number \( \kappa(\tilde{\mathbf{J}}) \) then better reflects actual sensitivity in a normalized space.

Recall from Lesson 2 that the manipulability measure \( \mu(\mathbf{q}) = \sqrt{\det(\mathbf{J}\mathbf{J}^\top)} \) is proportional to the volume of the velocity ellipsoid. The singular values \( \sigma_i \) are the semi-axes of this ellipsoid, so

\[ \mu(\mathbf{q}) = \prod_{i=1}^m \sigma_i(\mathbf{q}), \quad \kappa_2(\mathbf{J}) = \frac{\sigma_{\max}}{\sigma_{\min}}. \]

Thus:

• Manipulability reflects overall magnitude of velocity capability (volume).
• Condition number reflects isotropy of that capability (shape).

Both must be considered when designing trajectories that avoid singularities and numerically ill-conditioned configurations.

Consider a planar 2R arm 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),\quad y = \ell_1\sin q_1 + \ell_2\sin(q_1+q_2). \]

Differentiating yields the Jacobian

\[ \mathbf{J}(q_1,q_2) = \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}. \]

The following Python code computes \( \kappa_2(\mathbf{J}) \) on a grid and illustrates sensitivity of \( \delta\mathbf{x} \) to joint noise.

import numpy as np

# Simple 2R manipulator parameters
l1 = 1.0
l2 = 1.0

def jacobian_2r(q1, q2):
    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]
    ], dtype=float)
    return J

def kappa_2(J):
    # 2-norm condition number via singular values
    u, s, vt = np.linalg.svd(J)
    sigma_max = s[0]
    sigma_min = s[-1]
    return sigma_max / sigma_min

# Sample grid of configurations
q1_vals = np.linspace(-np.pi, np.pi, 81)
q2_vals = np.linspace(-np.pi, np.pi, 81)

kappa_map = np.zeros((len(q1_vals), len(q2_vals)))
for i, q1 in enumerate(q1_vals):
    for j, q2 in enumerate(q2_vals):
        J = jacobian_2r(q1, q2)
        # Avoid configurations where J is exactly singular in floating point
        if np.linalg.matrix_rank(J) < 2:
            kappa_map[i, j] = np.inf
        else:
            kappa_map[i, j] = kappa_2(J)

# Example: pick a configuration and simulate sensitivity
q1 = 0.0
q2 = 0.9
J = jacobian_2r(q1, q2)
kappa = kappa_2(J)
print("Condition number at (q1, q2) =", (q1, q2), "is", kappa)

# Joint noise model: small Gaussian perturbation
delta_q = np.array([1.0, -0.8]) * (np.pi / 180.0)  # 1 deg and -0.8 deg
delta_x = J @ delta_q

print("Joint perturbation (rad):", delta_q)
print("Task-space perturbation (m):", delta_x)
print("Amplification factor ||delta_x|| / ||delta_q|| =",
      np.linalg.norm(delta_x) / np.linalg.norm(delta_q))
      

In practice, robotics libraries such as roboticstoolbox-python provide Jacobians for many standard manipulators. One can simply compute the Jacobian using the library and pass it to numpy.linalg.cond(J, 2) to obtain \( \kappa_2(\mathbf{J}) \).

In C++, the Eigen library is a standard tool for linear algebra in robotics and is used inside several robotics frameworks (e.g., Orocos KDL, RBDL). The following snippet computes the Jacobian and its 2-norm condition number for the same planar 2R arm:

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

using Eigen::Matrix2d;
using Eigen::JacobiSVD;
using Eigen::ComputeFullU;
using Eigen::ComputeFullV;

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);

    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;
}

double cond2(const Matrix2d &J) {
    JacobiSVD<Matrix2d> svd(J, Eigen::ComputeFullU | Eigen::ComputeFullV);
    const auto &S = svd.singularValues();
    double sigma_max = S(0);
    double sigma_min = S(1);
    return sigma_max / sigma_min;
}

int main() {
    double l1 = 1.0, l2 = 1.0;
    double q1 = 0.0, q2 = 0.9;

    Matrix2d J = jacobian2R(q1, q2, l1, l2);
    double kappa = cond2(J);

    std::cout << "Jacobian J:\n" << J << "\n\n";
    std::cout << "Condition number kappa_2(J) = " << kappa << std::endl;
    return 0;
}
      

In more complex manipulators, Eigen::MatrixXd can be used and the Jacobian can be obtained from kinematics libraries like KDL, then passed to the same JacobiSVD-based condition number computation.

In Java, the EJML library is a popular choice for efficient dense linear algebra. The snippet below uses SimpleMatrix and its SVD to compute the condition number of the 2R Jacobian:

import org.ejml.simple.SimpleMatrix;

public class Planar2RCond {

    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);
    }

    static double cond2(SimpleMatrix J) {
        var svd = J.svd();
        double[] s = svd.getW().extractDiag().getDDRM().getData();
        double sigmaMax = Math.max(s[0], s[1]);
        double sigmaMin = Math.min(s[0], s[1]);
        return sigmaMax / sigmaMin;
    }

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

        SimpleMatrix J = jacobian2R(q1, q2, l1, l2);
        double kappa = cond2(J);

        System.out.println("J =");
        J.print();
        System.out.println("kappa_2(J) = " + kappa);
    }
}
      

In larger Java-based robotics systems (e.g., simulation servers or real-time controllers built on the JVM), this pattern can be reused for higher-dimensional Jacobians.

MATLAB has built-in support for singular values and condition numbers. For the planar 2R arm, we can write:

function [J, kappa] = jacobian2R_cond(q1, q2, l1, l2)
%JACOBIAN2R_COND Jacobian and condition number for planar 2R arm

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 ];

if rank(J) < 2
    kappa = Inf;
else
    % 2-norm condition number
    kappa = cond(J, 2);
end
end
      

To integrate this into Simulink for real-time monitoring:

1. Create a new MATLAB Function file (e.g., jacobian2R_cond.m) with the above code.
2. In a Simulink model, add a MATLAB Function block, open it, and call [J,kappa] = jacobian2R_cond(q1,q2,l1,l2); where the inputs are fed from joint signals and constants.
3. Connect the output kappa to a Scope or Display block to visualize how the condition number varies along a planned trajectory.

The same pattern generalizes to 6R manipulators once the corresponding Jacobian is implemented.

Wolfram Mathematica provides symbolic and numeric tools for analyzing Jacobians and condition numbers. For the 2R arm:

l1 = 1; l2 = 1;

J[q1_, q2_] := {
  { -l1*Sin[q1] - l2*Sin[q1 + q2], -l2*Sin[q1 + q2] },
  {  l1*Cos[q1] + l2*Cos[q1 + q2],  l2*Cos[q1 + q2] }
};

(* Singular values and condition number *)
singVals[q1_, q2_] := SingularValueList[J[q1, q2]];
kappa[q1_, q2_] := ConditionNumber[J[q1, q2]];

(* Example numeric evaluation *)
kappa[0, 0.9]

(* Contour plot of condition number over a joint-space region *)
ContourPlot[
  kappa[q1, q2],
  {q1, -Pi, Pi}, {q2, -Pi, Pi},
  Contours -> 20,
  PlotRange -> {1, 100},
  PlotLegends -> Automatic,
  FrameLabel -> {"q1", "q2", "kappa(J)"}
]
      

Symbolic manipulation (e.g., Simplify and Assuming) can be used to study asymptotic behavior of \( \kappa(\mathbf{J}) \) near singular configurations.

In this lesson we introduced matrix norms and condition numbers as rigorous tools to quantify sensitivity in differential kinematics. Using the singular values of the Jacobian, we defined the 2-norm condition number \( \kappa_2(\mathbf{J}) \) and showed how it diverges near singularities, complementing manipulability measures from the previous lesson. We derived bounds on the amplification of joint-space errors into task-space errors and vice versa, and emphasized the importance of metric and scaling choices when mixing rotational and translational components. Finally, we demonstrated how to compute and visualize Jacobian condition numbers in Python, C++, Java, MATLAB/Simulink, and Wolfram Mathematica.