Section 5.6: Inverse kinematics: analytic, numerical (Jacobian), and learned

A Careful Control Loop

This section develops the technical contract for Inverse kinematics: analytic, numerical (Jacobian), and learned 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 Inverse kinematics: analytic, numerical (Jacobian), and learned 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 Inverse kinematics: analytic, numerical (Jacobian), and learned, 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.

Inverse kinematics asks the harder direction: given a desired tool pose, which joint vector should produce it? The answer may be unique, absent, or one of many valid configurations. That is why every inverse-kinematics result must report the target frame, seed, residual, joint-limit margin, and whether the solver proved feasibility or merely stopped improving.

Analytic IK uses closed-form geometry when the arm structure permits it. Numerical IK iteratively reduces pose error with a Jacobian update. Learned IK uses data to predict candidate joint values, but still needs forward-kinematics and constraint checks because a neural prediction can be confident and infeasible at the same time.

Worked Example

The example solves position IK for the planar two-link arm from Section 5.5 with the damped least-squares update $\Delta q=J^\top(JJ^\top+\lambda^2 I)^{-1}\Delta x$, then replays the solution through forward kinematics to confirm the reached pose. Damping keeps the step bounded when the arm stretches toward a near-singular reach.

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 jacobian(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 ik_dls(target, q0, lam=0.05, iters=200, tol=1e-6):
    q = q0.astype(float).copy()
    for k in range(iters):
        dx = target - fk(q)
        if np.linalg.norm(dx) < tol:
            return q, k, np.linalg.norm(dx), True
        J = jacobian(q)
        dq = J.T @ np.linalg.solve(J @ J.T + lam**2*np.eye(2), dx)
        q += np.clip(dq, -0.2, 0.2)          # clamp per-step joint increment
    return q, iters, np.linalg.norm(target - fk(q)), False

target = np.array([0.6, 0.3])
q_sol, iters, res, ok = ik_dls(target, q0=np.deg2rad([10.0, 10.0]))
print("converged:", ok, "iters:", iters, "residual:", f"{res:.2e}")
print("solution (deg):", np.round(np.rad2deg(q_sol), 3))
print("FK replay      :", np.round(fk(q_sol), 6), "target:", target)

# Unreachable target (beyond l1+l2 = 0.9 m): solver must NOT report success
_, _, res_far, ok_far = ik_dls(np.array([1.5, 0.0]), q0=np.deg2rad([10.0, 10.0]))
print("far target -> converged:", ok_far, "residual:", f"{res_far:.3f} m")

The FK replay closes the loop: a solver that returns its last iterate without checking the residual would silently pass the unreachable target. Reporting convergence flag, residual, and an FK replay together is what separates a usable IK result from a stopped optimizer.

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

Inverse kinematics: analytic, numerical (Jacobian), and learned 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.

Treat inverse kinematics as constrained search, with residuals, limits, seeds, and infeasibility explicitly logged. 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 Inverse kinematics: analytic, numerical (Jacobian), and learned 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 target reachability, seed choice, residual definition, joint limits, damping, and frame convention before blaming the planner. For this section, first reproduce one planar inverse-kinematics target by hand, then rerun it through Pinocchio, Robotics Toolbox for Python, MoveIt 2, Drake, or a learned candidate generator with a forward-kinematics verifier. If the two disagree, inspect conventions and timing before changing the model.