Consider a serial manipulator with joint configuration \( \mathbf{q} \in \mathbb{R}^n \) and task-space (operational space) coordinates \( \mathbf{x} \in \mathbb{R}^m \), typically \( m=3 \) (position) or \( m=6 \) (position + orientation). The forward kinematics is a smooth map

\[ \mathbf{f} : \mathcal{Q} \subset \mathbb{R}^n \to \mathcal{X} \subset \mathbb{R}^m, \qquad \mathbf{x} = \mathbf{f}(\mathbf{q}), \]

whose differential (Jacobian) at configuration \( \mathbf{q} \) is

\[ \mathbf{J}(\mathbf{q}) = \frac{\partial \mathbf{f}}{\partial \mathbf{q}}(\mathbf{q}) \in \mathbb{R}^{m \times n}, \qquad \dot{\mathbf{x}} = \mathbf{J}(\mathbf{q}) \, \dot{\mathbf{q}}. \]

Intuitively, \( \mathbf{J}(\mathbf{q}) \) maps instantaneous joint velocities to instantaneous end-effector twist. When \( \mathbf{J}(\mathbf{q}) \) loses rank, some task directions become unreachable (loss of dexterity), or the inverse mapping from task-space velocities to joint velocities ceases to exist or becomes unbounded.

We adopt the following core definition:

Definition (kinematic singularity). A configuration \( \mathbf{q}^\star \) is a kinematic singularity if the Jacobian \( \mathbf{J}(\mathbf{q}^\star) \) has strictly smaller rank than its generic rank. For a non-redundant manipulator with \( m=n \), this is equivalent to \( \det\mathbf{J}(\mathbf{q}^\star)=0 \).

Algorithmic singularities are different: they arise because a chosen representation (e.g., Euler angles) or numerical algorithm (e.g., pseudoinverse IK with insufficient damping) becomes ill-defined or numerically unstable, even if the underlying geometry is non-singular.

flowchart TD
  Q["Configuration q"] --> J["Compute Jacobian J(q)"]
  J --> RANK["Check rank(J)"]
  RANK -->|full| REG["Regular configuration"]
  RANK -->|deficient| KS["Kinematic singularity"]
  KS --> BND["On workspace boundary?"]
  BND -->|yes| BKS["Boundary-type \nkinematic singularity"]
  BND -->|no| IKS["Interior-type \nkinematic singularity"]
  REG --> ALGTEST["Run IK / orientation algorithm"]
  ALGTEST -->|numerical issues only| AS["Algorithmic singularity \n(representation / numeric)"]
        

In the remainder of this lesson, we make these notions precise, show how they appear in classical examples, and prepare the ground for quantitative measures (manipulability, condition numbers) to be studied in subsequent lessons.

For a non-redundant manipulator with \( m=n \), the forward map \( \mathbf{f} : \mathbb{R}^n \to \mathbb{R}^n \) admits a particularly clear characterization via the inverse function theorem.

Theorem (informal inverse function theorem). Suppose \( \mathbf{f} : \mathbb{R}^n \to \mathbb{R}^n \) is smooth, and let \( \mathbf{J}(\mathbf{q}_0) \) be its Jacobian at \( \mathbf{q}_0 \). If \( \det\mathbf{J}(\mathbf{q}_0) \neq 0 \), then there exist open neighborhoods \( U \) of \( \mathbf{q}_0 \) and \( V \) of \( \mathbf{x}_0 = \mathbf{f}(\mathbf{q}_0) \) such that \( \mathbf{f}\vert_U : U \to V \) is a smooth bijection with smooth inverse.

In manipulator terms, if \( \det\mathbf{J}(\mathbf{q}_0) \neq 0 \), then near \( \mathbf{q}_0 \) there is a unique joint configuration for each nearby end-effector pose, and differential IK using the inverse Jacobian is well-posed. Conversely, if \( \det\mathbf{J}(\mathbf{q}_0) = 0 \), the inverse function theorem fails: local one-to-one correspondence between joint space and task space breaks down.

For a redundant manipulator with \( n > m \), the Jacobian is rectangular. Its singularity is defined by rank deficiency:

\[ \operatorname{rank} \mathbf{J}(\mathbf{q}) = r_{\max} \quad \text{(generic configuration)}, \qquad \operatorname{rank} \mathbf{J}(\mathbf{q}^\star) < r_{\max} \quad \Rightarrow \quad \mathbf{q}^\star \text{ singular}. \]

At such singular points, the dimension of the null space \( \mathcal{N}(\mathbf{J}(\mathbf{q})) = \{\dot{\mathbf{q}} : \mathbf{J}(\mathbf{q})\dot{\mathbf{q}} = \mathbf{0}\} \) jumps, leading to self-motions or loss of controllable task-space directions.

From a geometric viewpoint, \( \mathbf{J}(\mathbf{q}) \) describes the tangent map between the joint-space manifold and the task-space manifold \( SE(3) \). Singularities correspond to configurations where this tangent map fails to be of maximal rank.

Consider a two-revolute (2R) planar manipulator with link lengths \( \ell_1, \ell_2 > 0 \) and joint variables \( \theta_1, \theta_2 \). Its end-effector position in the plane is

\[ \begin{aligned} x(\theta_1,\theta_2) &= \ell_1 \cos\theta_1 + \ell_2 \cos(\theta_1+\theta_2), \\ y(\theta_1,\theta_2) &= \ell_1 \sin\theta_1 + \ell_2 \sin(\theta_1+\theta_2). \end{aligned} \]

The Jacobian mapping joint velocities \( \dot{\boldsymbol{\theta}} = [\dot{\theta}_1, \dot{\theta}_2]^\top \) to end-effector linear velocities \( [\dot{x}, \dot{y}]^\top \) is

\[ \mathbf{J}(\theta_1,\theta_2) = \begin{bmatrix} \frac{\partial x}{\partial \theta_1} & \frac{\partial x}{\partial \theta_2} \\ \frac{\partial y}{\partial \theta_1} & \frac{\partial y}{\partial \theta_2} \end{bmatrix} = \begin{bmatrix} -\ell_1 \sin\theta_1 - \ell_2 \sin(\theta_1+\theta_2) & -\ell_2 \sin(\theta_1+\theta_2) \\ \ell_1 \cos\theta_1 + \ell_2 \cos(\theta_1+\theta_2) & \ell_2 \cos(\theta_1+\theta_2) \end{bmatrix}. \]

For a 2D task space, the generic Jacobian rank is 2. Singularities occur when \( \det\mathbf{J} = 0 \). Computing the determinant:

\[ \det\mathbf{J} = (-\ell_1 \sin\theta_1 - \ell_2 \sin(\theta_1+\theta_2))\, \ell_2 \cos(\theta_1+\theta_2) - \\ (-\ell_2 \sin(\theta_1+\theta_2))\, (\ell_1 \cos\theta_1 + \ell_2 \cos(\theta_1+\theta_2)). \]

Grouping terms in \( \ell_1 \ell_2 \) and using trigonometric identities, one obtains

\[ \det\mathbf{J} = \ell_1 \ell_2 \sin\theta_2. \]

Thus singularities are characterized by \( \sin\theta_2 = 0 \), i.e. \( \theta_2 = 0 \) or \( \theta_2 = \pi \) (modulo \(2\pi\)). These correspond to fully stretched and fully folded elbow configurations. At such points, both joint axes become locally aligned, the arm loses one instantaneous direction of motion, and only velocities orthogonal to the arm can be produced.

On the workspace level, the reachable set of end-effector positions is

\[ \mathcal{W} = \left\{ (x,y) : (\ell_1-\ell_2)^2 \le x^2 + y^2 \le (\ell_1+\ell_2)^2 \right\}. \]

The singular configurations with \( \theta_2 = 0 \) or \( \theta_2 = \pi \) map exactly to the inner and outer circles bounding \( \mathcal{W} \). They are therefore boundary-type kinematic singularities.

Modern manipulator theory classifies kinematic singularities according to geometric and functional properties. For serial chains, three frequently used categories are:

1. Boundary singularities. The end-effector lies on the boundary of the reachable workspace. The 2R example above is prototypical. Small joint motions cannot produce all possible task-space motions in the outward radial direction.
2. Interior singularities. The end-effector is in the interior of the workspace, but different inverse-kinematic branches intersect (e.g., elbow-up and elbow-down configurations of more complex arms coinciding). Algebraically, the Jacobian loses rank in the interior of \( \mathcal{W} \). These often occur when three neighboring joint axes become coplanar or intersect in a special way (e.g., spherical wrists).
3. Structural vs. accidental singularities. Some singular sets are dictated by the joint-axis arrangement alone (structural), while others may arise only for special link-length combinations or special subspaces of motion (accidental).

From the differential viewpoint, the loss of rank of \( \mathbf{J}(\mathbf{q}) \) implies one of two qualitative phenomena:

• Loss of controllable directions. Some task-space directions \( \dot{\mathbf{x}} \) are no longer in the image of \( \mathbf{J}(\mathbf{q}) \), so they cannot be produced by any joint velocity.
• Growth of self-motion space. The null space \( \mathcal{N}(\mathbf{J}(\mathbf{q})) \) enlarges, giving rise to additional internal motions \( \dot{\mathbf{q}} \neq \mathbf{0} \) with zero end-effector velocity.

In redundant manipulators, singularities often manifest as sudden changes in the dimension of the self-motion manifold. For instance, a 7R arm may generically have a one-dimensional self-motion manifold for a fixed end-effector pose; at an interior singularity, this self-motion manifold may shrink or expand, affecting redundancy resolution strategies.

5.1 Orientation Parameterization Singularities

Orientation is often represented using Euler angles, for example a ZYX convention with angles \( (\phi,\theta,\psi) \). The body angular velocity vector \( \boldsymbol{\omega} \in \mathbb{R}^3 \) is related to Euler angle rates by

\[ \boldsymbol{\omega} = \mathbf{T}(\phi,\theta,\psi) \begin{bmatrix} \dot{\phi} \\ \dot{\theta} \\ \dot{\psi} \end{bmatrix}, \]

where \( \mathbf{T}(\phi,\theta,\psi) \) is a configuration-dependent \(3 \times 3\) matrix. For the ZYX convention, \( \det\mathbf{T}(\phi,\theta,\psi) = \cos\theta \), so \( \mathbf{T} \) becomes singular whenever \( \theta = \pm \frac{\pi}{2} \) (gimbal lock).

Note that in such a configuration, the physical orientation (a rotation matrix in \( SO(3) \)) is perfectly regular. It is only the Euler-angle parameterization that fails to be locally invertible. This is a classic example of a representation singularity:

• The robot kinematics (mapping from joint space to \( SE(3) \)) may be non-singular.
• But the chosen minimal coordinate chart (Euler angles) is singular.

Such representation singularities are typically handled by switching charts (e.g., different Euler-angle sequence) or using globally non-singular representations like unit quaternions.

5.2 Numerical IK and Pseudoinverse-Based Algorithmic Singularities

A common numerical inverse-kinematics (IK) scheme uses the Jacobian pseudoinverse. Let \( \mathbf{x}_d \) be the desired task-space pose and \( \mathbf{e}(\mathbf{q}) = \mathbf{x}_d - \mathbf{f}(\mathbf{q}) \) be the task-space error. A basic iterative IK algorithm is

\[ \mathbf{q}_{k+1} = \mathbf{q}_k + \mathbf{J}(\mathbf{q}_k)^{+}\, \mathbf{e}(\mathbf{q}_k), \]

where \( \mathbf{J}^{+} \) is the Moore–Penrose pseudoinverse. Using the singular value decomposition (SVD) \( \mathbf{J} = \mathbf{U}\boldsymbol{\Sigma}\mathbf{V}^\top \) with singular values \( \sigma_1 \ge \cdots \ge \sigma_r > 0 \), the pseudoinverse is

\[ \mathbf{J}^{+} = \mathbf{V}\boldsymbol{\Sigma}^{+}\mathbf{U}^\top, \qquad \boldsymbol{\Sigma}^{+} = \operatorname{diag}\left(\frac{1}{\sigma_1},\dots,\frac{1}{\sigma_r}\right). \]

If the smallest singular value \( \sigma_r \) is very small (near a kinematic singularity), then \( 1/\sigma_r \) is very large, and the joint update \( \Delta\mathbf{q} = \mathbf{J}^{+}\mathbf{e} \) can become extremely large even for modest task-space error \( \mathbf{e} \). This leads to:

• numerical overflow or loss of precision,
• violation of joint limits in a single iteration,
• oscillatory or divergent behavior of the IK algorithm.

These failures, including those driven by finite step sizes, damping choices, or orientation parameterization, are collectively referred to as algorithmic singularities. They depend on the algorithm, not only on the robot geometry.

A common remedy is the damped least-squares update, replacing \( \boldsymbol{\Sigma}^{+} \) by

\[ \boldsymbol{\Sigma}_{\lambda}^{+} = \operatorname{diag}\left( \frac{\sigma_1}{\sigma_1^2+\lambda^2},\dots, \frac{\sigma_r}{\sigma_r^2+\lambda^2} \right), \]

which keeps the joint updates bounded even when some \( \sigma_i \to 0 \). The choice of damping parameter \( \lambda \) is itself algorithmic and will be studied in more detail in later lessons on redundancy resolution and manipulability.

We now implement basic kinematic singularity checks for the 2R planar arm using multiple languages. In all cases we exploit the analytic determinant \( \det\mathbf{J} = \ell_1\ell_2\sin\theta_2 \). In practice, robotics libraries provide higher-level primitives; we briefly mention them for each language.

flowchart TD
  START["Joint config (theta1, theta2)"] --> JAC["Compute detJ = l1*l2*sin(theta2)"]
  JAC --> THR["Compare |detJ| with threshold"]
  THR -->|small| FLAG["Flag near kinematic singularity"]
  THR -->|normal| OK["Configuration acceptable"]
  FLAG --> ALG["If using IK: enable damping / reduce step"]
        

6.1 Python (NumPy, with note on robotics toolboxes)

Popular Python robotics ecosystems include modern_robotics (Lynch & Park) and roboticstoolbox-python (Corke), both of which compute Jacobians and manipulability indices. Below we implement a low-level check using numpy, independent of any toolbox.

import numpy as np

def det_jacobian_2r(theta1, theta2, l1=1.0, l2=1.0):
    """
    Determinant of the 2x2 Jacobian for a planar 2R arm.
    """
    return l1 * l2 * np.sin(theta2)

def is_kinematic_singular(theta1, theta2, l1=1.0, l2=1.0, tol=1e-6):
    detJ = det_jacobian_2r(theta1, theta2, l1, l2)
    return abs(detJ) < tol

def jacobian_2r(theta1, theta2, l1=1.0, l2=1.0):
    s1, c1 = np.sin(theta1), np.cos(theta1)
    s12, c12 = np.sin(theta1 + theta2), np.cos(theta1 + theta2)
    J = np.array([
        [-l1 * s1 - l2 * s12, -l2 * s12],
        [ l1 * c1 + l2 * c12,  l2 * c12]
    ])
    return J

def damped_pseudoinverse_step(theta1, theta2, dx,
                              l1=1.0, l2=1.0,
                              lam=1e-2):
    """
    One damped least-squares IK step in joint space:
        dq = J^T (J J^T + lam^2 I)^{-1} dx
    for a 2x2 Jacobian J.
    """
    J = jacobian_2r(theta1, theta2, l1, l2)
    JJt = J @ J.T
    lam2I = (lam ** 2) * np.eye(2)
    dq = J.T @ np.linalg.solve(JJt + lam2I, dx)
    return dq

# Example usage
theta1, theta2 = 0.0, 0.0   # fully stretched, singular
print("detJ =", det_jacobian_2r(theta1, theta2))
print("is singular? ", is_kinematic_singular(theta1, theta2))
      

6.2 C++ (pure math; note on KDL / ROS)

In C++-based robotics (e.g., ROS), the Orocos Kinematics and Dynamics Library (KDL) and Jacobian utilities in MoveIt rely heavily on Eigen for matrix computations. Here we show a minimal implementation using only <cmath>.

#include <cmath>
#include <iostream>

double detJacobian2R(double theta1, double theta2,
                     double l1, double l2)
{
    return l1 * l2 * std::sin(theta2);
}

bool isKinematicSingular(double theta1, double theta2,
                         double l1, double l2,
                         double tol)
{
    double detJ = detJacobian2R(theta1, theta2, l1, l2);
    return std::fabs(detJ) < tol;
}

int main()
{
    double l1 = 1.0, l2 = 1.0;
    double theta1 = 0.0;
    double theta2 = 0.0; // singular (fully stretched)

    double detJ = detJacobian2R(theta1, theta2, l1, l2);
    std::cout << "detJ = " << detJ << std::endl;
    std::cout << "singular? "
              << (isKinematicSingular(theta1, theta2, l1, l2, 1e-6)
                  ? "yes" : "no")
              << std::endl;
    return 0;
}
      

6.3 Java (determinant test; note on EJML)

Java robotics projects often use linear-algebra libraries such as EJML or Apache Commons Math to implement kinematics and dynamics. As with C++, the determinant formula allows a simple kinematic singularity test without constructing the full Jacobian matrix.

public class Planar2RSingularity {

    public static double detJacobian2R(double theta1, double theta2,
                                       double l1, double l2) {
        return l1 * l2 * Math.sin(theta2);
    }

    public static boolean isKinematicSingular(double theta1, double theta2,
                                              double l1, double l2,
                                              double tol) {
        double detJ = detJacobian2R(theta1, theta2, l1, l2);
        return Math.abs(detJ) < tol;
    }

    public static void main(String[] args) {
        double l1 = 1.0, l2 = 1.0;
        double theta1 = 0.0;
        double theta2 = Math.PI; // folded singularity

        double detJ = detJacobian2R(theta1, theta2, l1, l2);
        System.out.println("detJ = " + detJ);
        System.out.println("singular? "
                           + (isKinematicSingular(theta1, theta2, l1, l2, 1e-6)
                              ? "yes" : "no"));
    }
}
      

6.4 MATLAB / Simulink (with Robotics System Toolbox)

MATLAB provides the robotics.RigidBodyTree class in the Robotics System Toolbox. A typical singularity check is:

% Define 2R rigid body tree (conceptual; details omitted)
robot = robotics.RigidBodyTree("DataFormat","row");
% ... add bodies and joints to 'robot' ...

% Example configuration [theta1 theta2]
q = [0 0];  % fully stretched

% Compute body Jacobian for end-effector
J = geometricJacobian(robot, q, robot.BodyNames{end});

% Kinematic singularity test via determinant (2D task)
detJ = det(J(1:2, 1:2));   % assume planar model
isSingular = abs(detJ) < 1e-6

% In Simulink, this logic can be embedded in a MATLAB Function block that
% takes q(t) as input and outputs a boolean singularity flag.
      

In pure MATLAB without toolboxes, one can directly implement detJ = l1*l2*sin(theta2); using time-varying joint trajectories.

6.5 Wolfram Mathematica (symbolic derivation)

Symbolic tools make it easy to verify singular sets analytically.

(* Link lengths and joint angles *)
ClearAll[l1, l2, th1, th2];
x[th1_, th2_] := l1 Cos[th1] + l2 Cos[th1 + th2];
y[th1_, th2_] := l1 Sin[th1] + l2 Sin[th1 + th2];

(* Jacobian matrix *)
J = {
  {D[x[th1, th2], th1], D[x[th1, th2], th2]},
  {D[y[th1, th2], th1], D[y[th1, th2], th2]}
} // Simplify;

(* Determinant *)
detJ = Det[J] // Simplify

(* Solve for singularity condition detJ == 0 *)
singularSet = Solve[detJ == 0, th2]
      

The solution singularSet confirms that th2 == 0 or th2 == Pi (modulo \(2\pi\)), reproducing the analytical result.

In this lesson we defined kinematic singularities in terms of Jacobian rank deficiency and linked them to local invertibility of the forward-kinematic map via the inverse function theorem. Using the 2R planar arm, we explicitly derived singular sets and related them to the workspace boundary. We distinguished boundary and interior singularities, as well as structural versus accidental ones.

We then introduced representation and algorithmic singularities, with orientation parameterization (Euler-angle gimbal lock) and Jacobian pseudoinverse IK providing canonical examples. Finally, we implemented simple singularity checks across Python, C++, Java, MATLAB/Simulink, and Wolfram Mathematica, illustrating how singularities can be detected and monitored computationally. Subsequent lessons will quantify the severity of singularities via manipulability measures and condition numbers, and connect them to workspace analysis and control strategies.