Understand Inverse
Kinematics

Chapter 1: Forward Kinematics First

Before we can invert kinematics, we need to thoroughly understand the forward direction. Forward kinematics (FK) computes the end-effector position given all joint angles. For a planar 2-link arm, it's pure trigonometry — and it's the foundation everything else builds on.

The 2-Link Planar Arm

Picture two rigid links connected by revolute joints (joints that rotate). The first link of length L₁ attaches to a fixed base at the origin. It rotates by angle θ₁ measured counter-clockwise from the positive x-axis. The second link of length L₂ attaches to the end of the first link, rotating by θ₂ relative to the first link's direction.

Where is the elbow (the point where the two links meet)?

This is just polar-to-Cartesian conversion. The first link starts at the origin and extends at angle θ₁ for length L₁.

Where is the end-effector (the tip of the second link)? The second link starts at the elbow and extends at the absolute angle θ₁ + θ₂. Why the sum? Because θ₂ is measured relative to link 1, so the total angle from horizontal is θ₁ + θ₂.

That's it. Two equations mapping two joint angles to one 2D point. Forward kinematics is just a chain of rotations — each joint rotates everything downstream of it.

Worked Example: Step by Step

Let's compute FK with concrete numbers. Set L₁ = 1.0, L₂ = 0.7, θ₁ = 45°, θ₂ = 30°.

Step 1: Convert degrees to radians (since cos/sin expect radians in most programming languages):

Step 2: Compute the absolute angle of link 2:

Step 3: Compute the elbow position:

Step 4: Compute the end-effector position:

Verify: The arm points upward and slightly to the right. At 75° total angle, the hand is nearly vertical. The numbers match our geometric intuition. Set the sliders in the widget above to θ₁=45, θ₂=30 and confirm!

From 2D to 3D

In 3D, the same principle applies but with rotation matrices instead of single angles. Each joint has a rotation axis (not just "counter-clockwise"), and the FK chain becomes a product of 4×4 homogeneous transformation matrices. We'll build up to that in Chapters 5 and 6.

python
import numpy as np

def fk_2r(theta1, theta2, L1=1.0, L2=0.7):
    """Forward kinematics for a 2-link planar arm."""
    x = L1 * np.cos(theta1) + L2 * np.cos(theta1 + theta2)
    y = L1 * np.sin(theta1) + L2 * np.sin(theta1 + theta2)
    return x, y

# Example: theta1=45°, theta2=30°
x, y = fk_2r(np.radians(45), np.radians(30))
print(f"End-effector: ({x:.3f}, {y:.3f})")
# Output: End-effector: (0.888, 1.383)

Chapter 2: The 2R IK Problem

Now we flip the problem. Given a target position (x, y), find the joint angles θ₁, θ₂ that place the end-effector there. This is the simplest possible inverse kinematics problem — only two unknowns — and it already reveals the core challenges: multiple solutions, workspace limits, and the power of geometric thinking.

The Geometric Approach

Instead of staring at the FK equations and trying to algebraically invert them, let's think geometrically. We have a triangle.

The three sides are:

• L₁ — the first link (from base to elbow)
• L₂ — the second link (from elbow to end-effector)
• d — the distance from base to target: d = √(x² + y²)

By the law of cosines, we can relate the interior angle at the elbow to these three sides:

Why π − θ₂? Because the interior angle of the triangle at the elbow is the supplement of θ₂. When θ₂ = 0, the arm is fully extended and the interior angle is π (180°). When θ₂ = π, the arm folds back on itself and the interior angle is 0.

Since cos(π − θ₂) = −cos(θ₂), we can rearrange:

Call this value c₂. This is a single number computed directly from the target position and the link lengths. Three things can happen:

• |c₂| < 1: Two solutions exist (elbow-up and elbow-down)
• |c₂| = 1: Exactly one solution (arm fully extended or fully folded)
• |c₂| > 1: No solution exists (target is unreachable)

Finding θ₂: The atan2 Trick

A naive approach would be θ₂ = arccos(c₂), giving two solutions ±arccos(c₂). But never use arccos for IK. Here's why:

At the workspace boundary (c₂ = ±1), the derivative of arccos is infinite. A tiny numerical error in c₂ (say, 1.0000001 instead of 1.0) produces a NaN. The robust approach computes both sin(θ₂) and cos(θ₂) separately:

The positive square root gives elbow-up. The negative gives elbow-down. Two physically different arm configurations that reach the same target.

Finding θ₁

Once we know θ₂ (and therefore c₂ and s₂), the FK equations become linear in sin(θ₁) and cos(θ₁). Let's see why.

Expand the FK equations using angle addition formulas:

Group the sinθ₁ and cosθ₁ terms:

Let k₁ = L₁ + L₂ c₂ and k₂ = L₂ s₂. Then:

This elegant formula has a geometric interpretation: atan2(y, x) is the angle from the base to the target, and atan2(k₂, k₁) is the offset angle caused by the elbow bend.

Worked Example

Target: (1.2, 0.8), L₁ = 1.0, L₂ = 0.8.

Step 1 — Compute c₂:

Step 2 — Compute s₂ and θ₂:

Elbow-up: θ₂ = atan2(0.9614, 0.275) = 74.0°

Elbow-down: θ₂ = atan2(−0.9614, 0.275) = −74.0°

Step 3 — Compute θ₁ (for elbow-up):

Step 4 — Verify with FK:

The FK output matches the target exactly. Always verify IK solutions with FK — it's the cheapest debugging step in robotics.

Workspace: Where Can the Arm Reach?

The set of reachable points forms an annular ring (donut shape). The outer boundary is r_max = L₁ + L₂ (arm fully extended, θ₂ = 0). The inner boundary is r_min = |L₁ − L₂| (arm folded back, θ₂ = π). Any target inside this ring has exactly two IK solutions. Any target outside has zero.

python
import numpy as np

def ik_2r(x, y, L1=1.0, L2=0.8):
    """Inverse kinematics for 2R planar arm. Returns list of (th1, th2) pairs."""
    d2 = x**2 + y**2
    c2 = (d2 - L1**2 - L2**2) / (2 * L1 * L2)
    if abs(c2) > 1:
        return []  # unreachable
    solutions = []
    for sign in [1, -1]:
        s2 = sign * np.sqrt(max(0, 1 - c2**2))
        th2 = np.arctan2(s2, c2)
        k1 = L1 + L2 * c2
        k2 = L2 * s2
        th1 = np.arctan2(y, x) - np.arctan2(k2, k1)
        solutions.append((th1, th2))
    return solutions

# Verify:
for th1, th2 in ik_2r(1.2, 0.8):
    x, y = fk_2r(th1, th2, 1.0, 0.8)
    print(f"th1={np.degrees(th1):.1f}° th2={np.degrees(th2):.1f}° -> ({x:.3f}, {y:.3f})")

Chapter 3: The Geometric Insight — Circles

In Chapter 2, we solved 2R IK with the law of cosines. That worked beautifully for two joints in a plane. But real robots have six joints in 3D space, with arbitrary axis orientations. How do we scale up?

The IK-Geo framework (Elias & Wen, 2022) provides an elegant answer. The key insight is deceptively simple, and once you see it, you can't unsee it.

Rotation Traces a Circle

When you rotate a point p around an axis k by angle θ, the point traces out a circle. This is true in any number of dimensions, but it's easiest to visualize in 3D.

The circle lies on a plane perpendicular to k, centered at the point where k passes closest to p. The radius of the circle is the perpendicular distance from p to the axis k.

In 2D, this is obvious — rotating a point around the origin sweeps a circular arc. In 3D, the same thing happens, but the circle lives on a cone around the rotation axis. Think of a spinning top: a point on the rim traces a circle around the spin axis.

Subproblem 1: Circle Meets Point

The simplest geometric IK subproblem: given a rotation axis k and a point p₁, find the angle θ that rotates p₁ as close as possible to a target point p₂.

Geometrically: the set of all points R(k, θ)p₁ as θ varies is a circle. We need the point on this circle closest to p₂.

The solution is elegant: project both p₁ and p₂ onto the plane perpendicular to k. The angle between their projections is θ. If p₂ lies exactly on the circle, we get an exact match. Otherwise, we get the closest point. At most one solution.

Subproblem 2: Two Circles Intersect

Now the case that connects directly to 2R IK: two joints, two unknowns. Rotating p₁ around axis k₁ traces one circle. Rotating p₂ around axis k₂ traces another circle. The IK solution requires both rotations to produce the same intermediate point — so we need the two circles to intersect.

Two circles in 3D can intersect at 0, 1, or 2 points. Each intersection gives a pair (θ₁, θ₂). This is exactly the elbow-up / elbow-down duality from Chapter 2 — but stated in pure geometry instead of trigonometric algebra.

The power of this perspective is that it generalizes effortlessly to 3D. The law of cosines only works for planar arms. The circle-intersection approach works for any pair of revolute joints, regardless of axis orientation.

The Unifying View

Here's why this geometric perspective is so powerful. Consider a 6R robot. Each joint traces a circle. The FK chain says: rotate point through circle 1, then circle 2, then circle 3, and so on. IK asks: for which specific angles on each circle does the composition reach the target?

IK-Geo decomposes this into subproblems. Sometimes you can solve two consecutive joints by intersecting their circles (SP2). Sometimes you need to intersect a circle with a sphere defined by a distance constraint (SP3). Sometimes with a plane (SP4). Each subproblem has a closed-form solution.

Chapter 4: All Six Subproblems

IK-Geo identifies six canonical subproblems. Every IK problem for a serial robot with revolute joints can be decomposed into combinations of these six building blocks. Each subproblem has a closed-form solution using atan2 — no numerical iteration, no arccos, no tangent half-angle substitution.

Let's meet all six.

SP1: Circle ∩ Point (1 solution)

Problem: Given axis k, find θ such that R(k, θ)p = q.

Method: Project p and q onto the plane perpendicular to k. The angle between the projections is θ. Compute via atan2 of the cross product and dot product of the projections.

Exact solution exists when: ‖p − (k·p)k‖ = ‖q − (k·q)k‖ and k·p = k·q. In words: both points must be the same distance from the axis and at the same height along the axis.

SP2: Two Circles (up to 2 solutions)

Problem: Given axes k₁, k₂, find θ₁, θ₂ such that R(k₁, θ₁)p₁ = R(k₂, θ₂)p₂.

Method: Each rotation traces a circle. Find where the two circles intersect. The intersection reduces to a 1D equation solvable with atan2.

Connection to 2R IK: This is exactly the elbow-up/down problem! SP2 is the generalization of 2R IK to arbitrary 3D axis orientations.

SP3: Circle ∩ Sphere (up to 2 solutions)

Problem: Find θ such that ‖R(k, θ)p − c‖ = r.

Method: The rotated point must land on a sphere of radius r centered at c. A circle and a sphere in 3D intersect at up to 2 points (think of a hula hoop passing through a basketball).

Why it matters: When solving for an arm's reach to a target, the constraint "joint 3's position is at distance d from joint 5's position" is naturally a sphere constraint. SP3 is the 3D generalization of our 2R law-of-cosines approach.

SP4: Circle ∩ Plane (up to 2 solutions)

Problem: Find θ such that n^T · R(k, θ)p = d.

Method: The rotated point must land on a plane defined by normal n and offset d. A circle intersects a plane at up to 2 points.

Use case: When a joint axis is parallel to a constraint direction, the problem reduces to a plane intersection.

SP5 and SP6: Multi-axis Subproblems (up to 4 solutions)

SP5: Three consecutive rotations with a known intermediate direction. Reduces to intersecting two circles derived from the outer rotations, with the middle rotation determined afterwards. Up to 4 solutions.

SP6: Four rotations split into two pairs, constrained by a distance equality. Also up to 4 solutions.

How Subproblems Compose

The maximum number of IK solutions for a 6R robot is determined by how the subproblems chain together. For a robot with a spherical wrist:

Chapter 5: Into 3D — Rotation Matrices

We've solved 2D IK. Real robots live in 3D. To handle 3D, we need the mathematical language of rotation matrices — 3×3 matrices that rotate vectors without stretching, shrinking, or reflecting them.

What Makes a Rotation Matrix Special?

A 3×3 matrix R is a rotation matrix if and only if:

• Orthogonal: R^TR = I (columns are perpendicular unit vectors)
• Proper: det(R) = +1 (no reflections, only rotations)

These two properties guarantee that rotation preserves distances and handedness. The set of all 3×3 rotation matrices forms a mathematical group called SO(3) — the Special Orthogonal group in 3 dimensions.

Axis-Angle Representation

Any 3D rotation can be described by two things: an axis (which direction to rotate around) and an angle (how far to rotate). This is the axis-angle representation: rotate by angle θ around unit vector k = [k_x, k_y, k_z].

The standard rotation matrices around the three coordinate axes are:

Notice the pattern: the row and column corresponding to the rotation axis are "identity-like" (1 on diagonal, 0 elsewhere). The other four entries form a 2D rotation.

The Rodrigues Formula

For rotation around an arbitrary axis k by angle θ, we use Rodrigues' rotation formula:

Where [k]_× is the skew-symmetric matrix that computes the cross product:

This means [k]_× v = k × v (cross product) for any vector v.

Let's unpack the three terms of Rodrigues' formula:

• I cosθ — scales the identity by cosθ. At θ=0, this is the dominant term (no rotation).
• (1 − cosθ) kk^T — the projection term. kk^T projects any vector onto the rotation axis. This component stays fixed during rotation. At θ=180°, cosθ=−1, so this term becomes 2kk^T, doubling the component along the axis while the I cosθ term subtracts the rest.
• sinθ [k]_× — the cross-product term. This creates the circular sweep perpendicular to both the axis and the vector being rotated.

Worked Example

Rotate v = [1, 0, 0] by 90° around k = [0, 0, 1] (the z-axis).

cos(90°) = 0, sin(90°) = 1.

Term 1: I · 0 = [[0,0,0],[0,0,0],[0,0,0]]

Term 2: (1 − 0) · kk^T = [[0,0,0],[0,0,0],[0,0,1]] (only the zz entry survives because k=[0,0,1])

Term 3: 1 · [k]_× = [[0,−1,0],[1,0,0],[0,0,0]]

Sum: R = [[0,−1,0],[1,0,0],[0,0,1]]

Apply: R · [1,0,0]^T = [0,1,0] ✓

The x-axis unit vector rotated 90° around z becomes the y-axis unit vector. This matches our geometric intuition: looking down at the xy-plane, a 90° counter-clockwise rotation sends x to y.

python
import numpy as np

def rodrigues(k, theta):
    """Rotation matrix from axis k (unit vector) and angle theta."""
    k = np.array(k, dtype=float)
    K = np.array([[0, -k[2], k[1]],
                  [k[2], 0, -k[0]],
                  [-k[1], k[0], 0]])
    I = np.eye(3)
    return I * np.cos(theta) + (1 - np.cos(theta)) * np.outer(k, k) + np.sin(theta) * K

# Verify: rotate [1,0,0] by 90° around z
R = rodrigues([0, 0, 1], np.pi/2)
v = R @ np.array([1, 0, 0])
print(v)  # [0, 1, 0]

Chapter 6: The 6R Robot Arm — 3D FK

Now we leave the plane and enter the real world: a 6-DOF robot arm with six revolute joints. Each joint rotates around its own axis. The forward kinematics is a chain of six rotations and translations, expressed as a product of homogeneous transformation matrices.

This is the robot arm that builds your car, fills your Amazon orders, and performs surgery. Let's understand it.

Homogeneous Transforms

In 3D, each link doesn't just rotate — it also translates. We need to handle both. A 4×4 homogeneous transformation matrix packs a rotation R and a translation d into a single matrix:

The beauty: composing two transforms (first transform by T₁, then by T₂) is just matrix multiplication:

This is the power of homogeneous coordinates. Rotation and translation, which are normally different operations, become a single matrix multiply.

The FK Chain

Each joint i has a rotation axis h_i and a reference position. The transform for joint i at angle q_i is a rotation of q_i around axis h_i, plus the fixed offset between joints.

The full FK from base (frame 0) to end-effector (frame 6) is:

This gives us a 4×4 matrix encoding both the position (where the hand is — the translation column) and orientation (which way it's pointing — the rotation block) of the end-effector. Six numbers in (the joint angles), twelve numbers out (3×3 rotation + 3×1 position). But the rotation has only 3 independent degrees of freedom (it's constrained to be orthogonal), so the output is truly 6-dimensional: 3 for position, 3 for orientation. This matches our 6 joint inputs.

UR5-like Configuration

Our visualization models a simplified UR5-like robot (Universal Robots UR5, one of the most common collaborative robots). The joint axes alternate between vertical (Y-axis) and horizontal (Z-axis) rotations, creating the familiar "elbow" shape:

Chapter 7: Decoupling Position and Orientation

Solving IK for six joints simultaneously sounds daunting. Six nonlinear equations in six unknowns, with trigonometric terms everywhere. But most industrial robots have a geometric trick up their sleeve that cuts the problem in half.

The Spherical Wrist

If the last three joint axes all intersect at a single point, the robot has a spherical wrist. The point where they intersect is called the wrist center.

Why does this help? Because the wrist center's position depends only on joints 1, 2, 3 (the "shoulder" and "elbow"). Joints 4, 5, 6 rotate the hand around the wrist center without moving it. This means we can split the 6-joint IK into two independent 3-joint problems:

1. Position subproblem (q₁, q₂, q₃): Place the wrist center at the correct position
2. Orientation subproblem (q₄, q₅, q₆): Rotate the hand to achieve the desired orientation

This is the Pieper criterion (1968): a 6R robot has closed-form IK if and only if three consecutive axes intersect at a point (or are parallel).

Finding the Wrist Center

The wrist center is offset from the end-effector by the tool length d₆ along the approach direction (the z-axis of the desired frame). If the desired end-effector pose is position p_target with rotation R_target, then:

In words: start at the desired hand position, walk backwards along the hand's z-axis by the wrist-to-tip distance. That's the wrist center. This is computable immediately from the desired pose — no joint angles needed yet.

Solving the Position Subproblem (Joints 1-3)

With the wrist center known, we need q₁, q₂, q₃ such that FK of joints 1-3 places the wrist center at p_wrist. For a typical industrial robot (UR5, KUKA, ABB, Fanuc):

q₁ (base rotation): This is usually the simplest. The base rotates around the vertical axis, so q₁ = atan2(p_wrist,y, p_wrist,x). But wait — there's an ambiguity. The arm can reach the same wrist center from the "front" or the "back" (shoulder left/right). That gives 2 solutions for q₁.

q₂, q₃ (shoulder + elbow): Once q₁ is fixed, the remaining problem is planar — exactly the 2R IK from Chapter 2! We project the wrist center into the plane of links 2 and 3, then use the law of cosines / circle-sphere intersection. 2 solutions (elbow up/down).

Total for position: 2 × 2 = 4 configurations.

Solving the Orientation Subproblem (Joints 4-6)

Once joints 1-3 are known, the rotation R₀₃ (from base to frame 3) is determined. The wrist must achieve the remaining rotation:

This is a known rotation matrix that must be decomposed into three rotations around the wrist axes. For a ZYZ wrist configuration (common in industrial robots), this is Euler angle extraction:

Extracting q₄, q₅, q₆ from R₃₆ is a well-known trigonometric exercise. The key: q₅ = atan2(√(r₃₁² + r₃₂²), r₃₃), and there are 2 solutions (wrist flip / no flip, corresponding to ±q₅).

For each of the 4 position solutions, there are 2 orientation solutions, giving 4 × 2 = 8 total IK solutions.

Chapter 8: Full IK Solver — All Solutions

This is the payoff chapter. Everything we've built — FK chains, the law of cosines, geometric subproblems, rotation matrices, position-orientation decoupling — comes together here. We build a complete IK solver for a 6R robot with a spherical wrist. Given a desired end-effector pose, we find all valid joint configurations.

The Solution Pipeline

Why 8 Solutions?

Each binary choice doubles the solution count:

• Shoulder: left or right (2 ways to reach around to the same side)
• Elbow: up or down (2 ways to bend the arm)
• Wrist: flip or no-flip (2 orientations of the wrist)

Each solution is a physically distinct robot configuration that reaches the same end-effector pose. They look completely different — the elbow points a different direction, the shoulder reaches around a different way — but the hand ends up in exactly the same place and orientation.

Selecting the "Best" Solution

With up to 8 solutions, which one should the robot use? Common criteria:

• Closest to current configuration: Minimize joint travel — fastest and safest
• Farthest from singularities: Maximize det(J) — most controllable
• Collision-free: Check each solution against the environment — most practical
• Joint limits: Some solutions may violate physical joint limits — mandatory filter

python
def ik_6r_spherical_wrist(p_target, R_target, robot):
    """Full IK for 6R robot with spherical wrist.
    Returns list of joint angle tuples (q1...q6)."""
    solutions = []

    # Step 1: Wrist center
    p_wrist = p_target - robot.d6 * R_target @ np.array([0,0,1])

    # Step 2: Solve q1 (2 solutions)
    for q1 in solve_base_angle(p_wrist):  # shoulder L/R

        # Step 3: Solve q2, q3 (2 solutions each)
        for q2, q3 in solve_elbow(p_wrist, q1, robot):  # elbow up/down

            # Step 4: Solve q4, q5, q6 (2 solutions)
            R03 = fk_rotation(q1, q2, q3, robot)
            R36 = R03.T @ R_target
            for q4, q5, q6 in euler_zyz(R36):  # wrist flip

                # Step 5: Check joint limits
                q = [q1, q2, q3, q4, q5, q6]
                if robot.within_limits(q):
                    solutions.append(q)

    return solutions  # up to 8 solutions

Chapter 9: When IK Breaks — Singularities

Not every robot configuration is created equal. At certain configurations called singularities, the robot loses a degree of freedom — it can't move in some direction no matter what it does. Understanding singularities is essential because they cause real-world catastrophes: infinite joint velocities, controller instability, and dangerous vibrations.

The Jacobian

The Jacobian J is a matrix that maps joint velocities to end-effector velocities:

For a 2R planar arm, J is 2×2:

Where s₁ = sinθ₁, c₁ = cosθ₁, s₁₂ = sin(θ₁+θ₂), c₁₂ = cos(θ₁+θ₂).

The determinant is:

This is zero when θ₂ = 0 or π — exactly when the arm is fully extended or fully folded.

What a Singularity Means Physically

When det(J) = 0, the Jacobian is not invertible. The equation q̇ = J⁻¹ v_ee breaks down. Physically, this means:

• Some Cartesian velocities require infinite joint speeds
• The robot loses one degree of freedom of motion
• IK solutions merge (two solutions become one)
• The velocity ellipsoid collapses to an ellipse (loses a dimension)

Three Types of Singularities

Workspace boundary singularity: The arm is fully extended (θ₂ = 0) or fully folded (θ₂ = π). At this configuration, the arm can only move tangentially — it physically cannot reach further outward or fold further inward. The two IK solutions (elbow-up and elbow-down) merge into one.

Internal singularity: Two joint axes align, creating redundancy in one direction and a dead zone in another. For example, when a robot's shoulder and elbow axes become coplanar, the arm can spin freely around one axis but can't generate velocity perpendicular to it.

Wrist singularity: When q₅ = 0 in a ZYZ wrist, axes 4 and 6 become collinear. The robot can spin joints 4 and 6 freely (only their sum q₄ + q₆ matters), but it's lost the ability to rotate about one axis. This is the most common singularity in industrial robots and must be carefully avoided during path planning.

IK Near Singularities

As the target approaches a singularity, the IK solutions become numerically ill-conditioned. Small changes in the target produce large jumps in joint angles. This is a fundamental mathematical property, not a bug in the solver. IK-Geo handles this gracefully because it uses atan2 (which is well-defined everywhere), but the solutions themselves become sensitive near singularities.

Chapter 10: Search-Based IK for General 6R

Everything so far assumes the robot has three consecutive axes that intersect (spherical wrist) or are parallel. But what about robots where no such structure exists? General 6R robots — where no three consecutive axes have special geometric relationships — have no closed-form IK solution. The system of equations is a polynomial of degree up to 16.

This is where IK-Geo's approach truly shines. Even for general robots, it doesn't abandon geometric reasoning for brute-force gradient descent. Instead, it reduces the problem to a 1D search over a single joint angle.

The 1D Search Strategy

The idea is beautiful in its simplicity. Pick one joint, say q₄. For any fixed value of q₄, the remaining five joints can be solved in closed form using subproblems. This is because fixing one angle creates enough geometric structure for the subproblems to apply.

So we define an error function:

Where q₁, q₂, q₃, q₅, q₆ are all determined (via subproblems) as functions of the fixed q₄. The zeros of e(q₄) are the IK solutions.

The algorithm:

1. Sweep q₄ from −π to π in small steps (e.g., 1000 samples)
2. At each sample, solve q₁-q₃ and q₅-q₆ in closed form via subproblems
3. Evaluate the error e(q₄)
4. Find zero crossings of e(q₄) using bisection or Newton's method
5. For each zero, read off all six joint angles

How Many Solutions?

A general 6R robot can have up to 16 IK solutions (proven by algebraic geometry — the system is a degree-16 polynomial). In practice, most configurations have 2-8 real solutions. IK-Geo's 1D search finds them all by sampling densely enough to catch every zero crossing.

For robots with 2D search (two free parameters), the problem becomes finding the zero contour of a 2D error function. This is more expensive but still vastly better than 6D gradient descent.

Chapter 11: Connections

Inverse kinematics is the bridge between intention and motion. Every time a robot arm reaches for an object, welds a seam, inserts a peg, catches a ball, or sutures a wound — IK is the silent translator converting desired end-effector poses into motor commands. You now understand the mathematics behind all of it.

What We Covered

IK Methods Compared

Where IK Lives in the Robot Stack

Extensions and Frontiers

Redundant robots (7+ DOF): The Franka Panda has 7 joints — one more than needed for 6-DOF tasks. The extra joint gives a continuous family of IK solutions parameterized by a redundancy angle. GeoFIK (Elias & Wen, 2025) solves this geometrically, finding all solutions along the redundancy manifold with analytical Jacobians as a byproduct.

Cuspidal robots: Some robots can change between IK solution branches without passing through a singularity. These cuspidal configurations create topological traps for path planners — a motion that looks smooth in Cartesian space may require a discontinuous jump in joint space. Elias & Wen (2025) developed specialized path planning algorithms that detect and handle cusp crossings.

Learning-based IK: Neural networks can approximate IK, especially for complex kinematic chains (humanoid hands, snake robots, soft robots). But they sacrifice guaranteed accuracy, completeness, and interpretability. Geometric methods remain the gold standard for precision applications where you need all solutions and need to know when IK is infeasible.

Related Lessons

• Classical SLAM — Where am I? Mapping while localizing
• Modern VIO — Visual-inertial odometry for real-time tracking
• Vision-Language-Action Models — End-to-end robot learning
• Markov Decision Processes — Planning under uncertainty
• Kalman Filter — Optimal state estimation for robot sensing

References

1. A. J. Elias & J. T. Wen. "IK-Geo: Unified Robot Inverse Kinematics Using Subproblem Decomposition." arXiv:2211.05737, 2022.
2. A. J. Elias & J. T. Wen. "GeoFIK: Fast Geometric Inverse Kinematics for the Franka Emika Panda." arXiv:2503.03992, 2025.
3. A. J. Elias & J. T. Wen. "Cuspidal-Aware Path Planning for Serial Manipulators." arXiv:2501.18505, 2025.
4. B. Pieper. "The kinematics of manipulators under computer control." PhD thesis, Stanford, 1968.
5. J. Craig. Introduction to Robotics: Mechanics and Control, 4th ed. Pearson, 2017.