Kinematic Redundancy

• Also called: manipulator redundancy
• Category: Foundations & spatial maths › Kinematics
• Tags: kinematics, inverse-kinematics, null-space, manipulators, redundancy-resolution

A robot is kinematically redundant for a task when it has more joints than the task needs, so the same end-effector pose can be reached with a continuous family of joint configurations.

Definition

A manipulator is kinematically redundant with respect to a task when its number of joints n exceeds the dimension m of the task it must control. The classic case is a seven-joint arm controlling a six-dimensional end-effector pose, which leaves one degree of redundancy. Redundancy is defined relative to the task, though: a six-joint arm is also redundant for a task that fixes only the position of a tool tip, or that leaves rotation about a drill axis free. For a fixed end-effector pose, the joint configurations that achieve it form not a single point but an (n − m)-dimensional family, often called the self-motion manifold. In practice this means the arm can move its elbow while the hand stays still.

At the velocity level, redundancy appears as the null space of the m × n manipulator Jacobian J: joint velocities in that null space produce no end-effector motion. Resolved-rate controllers use this with the standard form q̇ = J⁺ẋ + (I − J⁺J)q̇₀, where J⁺ is the pseudoinverse. The first term tracks the task, and the second projects a secondary objective q̇₀ into the null space. Common secondary objectives are staying away from joint limits, keeping the elbow clear of obstacles, increasing manipulability to avoid singularities and reducing joint torques. Task-priority inverse kinematics builds on this by ranking several tasks, so that each lower-priority task acts only in the null space of those above it.

Redundancy also changes how inverse kinematics behaves. A numerical IK solver returns one solution out of infinitely many, chosen implicitly by its seed and its algorithm, so consecutive queries can jump between distant configurations. Analytic IK for common seven-joint designs with a spherical shoulder and wrist parameterizes the extra freedom explicitly, often as an arm or swivel angle that rotates the elbow about the line from shoulder to wrist. Redundancy should not be confused with the finite set of discrete IK branches, such as elbow up or down and wrist flipped, that even non-redundant six-joint arms have.

Why it matters

Redundancy is what lets a seven-joint arm reach around obstacles, avoid joint limits and stay away from singularities while its hand follows a path, and it is why many collaborative and humanoid arms have seven joints. It also makes inverse kinematics and planning harder, because something must choose one configuration out of a continuum, and poor choices lead to joint-limit stops or sudden elbow flips.

Key applications

• Elbow obstacle and self-collision avoidance while the end effector tracks a path
• Joint-limit and singularity avoidance during long tool paths
• Bimanual and closed-chain manipulation, where spare freedom helps satisfy shared constraints
• Whole-body control of humanoids and mobile manipulators with many more joints than any single task needs
• Keeping arm posture predictable and clear of people in collaborative work
• Reducing joint torques or energy for a given end-effector motion

In practice

An engineer programs a seven-joint arm to wipe a table with a sponge while a person works nearby. The wiping path fixes the end-effector pose, leaving one free degree of freedom. The controller computes joint velocities with the Jacobian pseudoinverse for the wiping motion and adds a null-space term that pushes the elbow away from the person's tracked position and toward the middle of each joint's range. During testing, the team finds that a plain numerical IK solver called at each waypoint sometimes returns solutions with the elbow on opposite sides, causing large joint jumps. They switch to warm-starting each query from the previous solution and to parameterizing the elbow position explicitly with the arm angle, so the planner chooses the redundant degree of freedom deliberately instead of leaving it to the solver.

Common misconceptions

• Redundancy simply means having more than six joints — it is defined relative to the task, so a six-joint arm is redundant for a task that constrains fewer than six end-effector coordinates
• Redundant arms have multiple IK solutions in the same way six-joint arms do — non-redundant arms have a finite set of discrete solutions, while redundant arms have continuous families of them
• Null-space motion never affects the task — it leaves the end-effector pose unchanged only to first order, so large steps or motion near singularities can still disturb the task unless the error is corrected

Who should know this

• Manipulation and motion-planning engineers
• Control engineers working on task-space and whole-body control
• Humanoid and mobile-manipulator developers
• Robotics students studying manipulator kinematics

Related technologies

• Jacobian Pseudoinverse
• Null-Space Projection
• Analytic Inverse Kinematics
• Manipulability Ellipsoid
• Damped Least Squares

Related terms

• Inverse Kinematics
• Task-Priority Inverse Kinematics
• Jacobian
• DOF
• Configuration Space
• Constraint Manifold

Related projects

• MoveIt 2: Motion planning framework for ROS 2 robot arms, with kinematics and collision checking
• PyRoki: Modular Python toolkit for kinematic optimization across CPU, GPU, and TPU via JAX
• mink: Python inverse kinematics library built on MuJoCo supporting 20+ robot platforms
• DART: C++ physics engine for articulated rigid body dynamics and robotics simulation
• IKPy: Pure-Python inverse kinematics library that builds chains straight from URDF
• frax: JAX library for fast, differentiable robot kinematics, dynamics and inverse kinematics