Section 5.7: Jacobians, singularities, manipulability

A Careful Control Loop

This section develops the technical contract for Jacobians, singularities, manipulability into a usable mental model. First we define the object of study, then we connect it to the agent loop, then we test it with a compact implementation.

The key question in Jacobians, singularities, manipulability is practical: what must the agent know, what can it observe, what action is available, and what evidence shows that the action worked under the stated conditions?

Theory

For Jacobians, singularities, manipulability, the practical design rule is to make the interface inspectable before optimization begins: inputs, outputs, units, latency, bounds, and failure labels should all be visible in the saved artifact.

The Jacobian is the local translator between joint velocity and task velocity: $\dot x=J(q)\dot q$. It says what the arm can do in the next instant, not what it can reach eventually. That local nature is why a robot can be far from a joint limit yet still be temporarily unable to move the tool in one direction.

Singularities appear when $J(q)$ loses rank. In that posture, some task-space direction requires unbounded or very large joint velocity. Manipulability summarizes the same issue as a safety margin: large singular values mean easy motion in the corresponding direction, while tiny singular values warn that control authority is collapsing.

Worked Example

The example computes the Jacobian of the planar two-link arm two ways, by finite differences of forward kinematics and analytically, confirms they agree, then sweeps the elbow toward full extension to watch the manipulability $w=\sqrt{\det(JJ^\top)}$ and smallest singular value collapse at the singularity.

import numpy as np

l1, l2 = 0.5, 0.4

def fk(q):
    x = l1*np.cos(q[0]) + l2*np.cos(q[0]+q[1])
    y = l1*np.sin(q[0]) + l2*np.sin(q[0]+q[1])
    return np.array([x, y])

def jac_analytic(q):
    s1, s12 = np.sin(q[0]), np.sin(q[0]+q[1])
    c1, c12 = np.cos(q[0]), np.cos(q[0]+q[1])
    return np.array([[-l1*s1 - l2*s12, -l2*s12],
                     [ l1*c1 + l2*c12,  l2*c12]])

def jac_finite_diff(q, eps=1e-6):
    J = np.zeros((2, 2))
    for i in range(2):
        dq = np.zeros(2); dq[i] = eps
        J[:, i] = (fk(q + dq) - fk(q - dq)) / (2*eps)
    return J

q = np.deg2rad([35.0, 60.0])
print("max |analytic - finite diff|:",
      f"{np.max(np.abs(jac_analytic(q) - jac_finite_diff(q))):.2e}")

def manipulability(q):
    J = jac_analytic(q)
    return np.sqrt(max(np.linalg.det(J @ J.T), 0.0))

print(" elbow(deg)  w=sqrt(det(JJ^T))  sigma_min")
for q2_deg in [90, 30, 10, 2, 0]:
    q = np.deg2rad([35.0, q2_deg])
    sigma = np.linalg.svd(jac_analytic(q), compute_uv=False)
    print(f"   {q2_deg:4d}        {manipulability(q):.5f}        {sigma.min():.5f}")
# As the elbow straightens (q2 -> 0), w and sigma_min -> 0: a singularity.

The finite-difference cross-check certifies the analytic Jacobian on one posture; the sweep shows why manipulability is a usable early-warning signal. A controller that asks for fast Cartesian motion at $q_2\approx 0$ demands near-infinite joint velocity, so damping or task relaxation must engage before the singular value reaches the configured margin.

Practical Recipe

1. Write the observation, action, and success metric before choosing a model.
2. Build a baseline that is simple enough to debug by inspection.
3. Add the library implementation only after the baseline behavior is understood.
4. Record failures as structured cases: perception error, state error, planning error, control error, or evaluation error.
5. Run at least one perturbation test before trusting the result.

Production Pattern

Jacobians, singularities, manipulability sits inside the Part II robotics contract: geometry defines where things are, kinematics defines what motion is possible, dynamics defines what motion costs, control defines how errors are corrected, and sensing defines what the agent can know on time.

Track Jacobian rank, singular values, and manipulability before asking a controller for high task-space speed. This makes the section useful to students, builders, and researchers at the same time: the idea has an intuitive role, a formal interface, a runnable check, and a failure mode that can be reproduced.

Use this recipe when turning Jacobians, singularities, manipulability into code, a simulator experiment, or a robot diagnostic. The point is not to use every library. The point is to keep the hand-built baseline and the maintained-tool path comparable.

1. Write the joint vector, frame target, velocity convention, and constraint set before solving.
2. Check forward kinematics on a known posture, then perturb one joint and inspect the end-effector delta.
3. Compare an analytic or numerical Jacobian with Pinocchio, Robotics Toolbox, or Drake on the same robot model.
4. Log residual error, joint-limit distance, manipulability, and solver iteration count in one artifact.
5. Treat singularities and infeasible targets as design signals, not as solver annoyances.

Kinematic failures often arrive as a plausible pose with an impossible motion. Inspect Jacobian rank, singular values, task frame, joint velocity limits, and whether the task has fewer or more dimensions than the joints before blaming the planner. For this section, first reproduce one small Jacobian by finite differences, then rerun it through Pinocchio, Robotics Toolbox for Python, MoveIt 2, or Drake. If the two disagree, inspect conventions and timing before changing the model.