explainer
Kinematic singularities: find the tip velocities an arm can produce
Use a two-link robot arm to distinguish exact rank loss from near-singular conditioning. Calculate the minimum-norm joint rates for a requested tip velocity and identify the component the arm cannot produce.
What you will learn
- Define a singular configuration using the maximum rank attainable for a specified task.
- Identify the straight and folded singularities of a two-link position Jacobian.
- Calculate minimum-norm joint rates and the resulting velocity residual.
- Explain why a nearly straight arm can require very large joint rates.
- Distinguish a robot's task singularity from an orientation-coordinate singularity.
Before you start
A straight robot arm can sweep its tip sideways while having no instantaneous velocity along its own length. Bend the elbow slightly, and the missing direction returns. Producing a modest velocity in that direction may then require extremely fast joint motion.
Those are two different calculations: which velocities exist at this configuration, and how much joint motion a particular velocity requires. A kinematic singularity concerns the first. Conditioning helps describe the second.
Name the task before defining a singularity
A task Jacobian J maps joint rates θ̇ into a chosen task velocity. Its rank counts the independent instantaneous task directions available at the current configuration. A configuration is singular for that task when this rank falls below the maximum that the same robot and task can attain at other configurations. Modern Robotics defines singularities through this attainable maximum rank.
The task matters. We will control the two Cartesian coordinates of an arm's tip. Its position Jacobian has two rows and two columns, and its maximum rank is 2.
If we include planar orientation as a third task coordinate, the corresponding Jacobian has three rows and two columns. Two joints cannot independently command all three outputs. That structural limitation does not, by itself, identify a singular configuration. For this particular arm, the full planar pose map retains its maximum rank of 2 everywhere, including configurations where its position map drops to rank 1.
Differentiate a two-link position map
Use rigid links L₁ = 2 m and L₂ = 1 m, with a fixed shoulder at the world origin. The shoulder angle θ₁ is absolute, measured from world +x. The elbow angle θ₂ is relative to the first link. Positive angles turn counterclockwise, with +z out of the page.
The tip position is a column vector:
x = 2 cos θ₁ + cos(θ₁ + θ₂)
y = 2 sin θ₁ + sin(θ₁ + θ₂)
Differentiate each coordinate with respect to each angle. With c₁₂ = cos(θ₁ + θ₂) and s₁₂ = sin(θ₁ + θ₂):
J = [−2 sin θ₁ − s₁₂, −s₁₂;
2 cos θ₁ + c₁₂, c₁₂]
ṗ = Jθ̇
The semicolon separates the matrix rows. Derivatives use angles in radians, so J has units of m/rad and θ̇ uses rad/s. The experiment accepts degrees and converts them before evaluating the map.
Each column is the tip velocity produced by one joint moving at 1 rad/s while the other is stationary. The space and body Jacobian lesson explains how this point-velocity map differs from a twist Jacobian.
Find the straight and folded cases
Expanding the two-by-two determinant gives:
det J = L₁L₂ sin θ₂ = 2 sin θ₂
Thus the position map has rank 2 whenever sin θ₂ is nonzero. It drops to rank 1 at a straight elbow, θ₂ = 0, or a folded elbow, θ₂ = ±π, within the displayed angle range. Its second column always has length 1 m/rad, so the rank never falls to zero.
For θ₁ = 0, the exact matrices are:
| Configuration | Position Jacobian | Available tip velocities |
|---|---|---|
| Straight, θ₂ = 0 | [0, 0; 3, 1] | (0, 3θ̇₁ + θ̇₂) |
| Folded, θ₂ = π | [0, 0; 1, −1] | (0, θ̇₁ − θ̇₂) |
Both allow vertical velocity and block horizontal velocity at that instant. Rotating the shoulder rotates the available line in world coordinates. The unequal link lengths put the folded tip 1 m from the shoulder; singularity does not require the tip to coincide with the base.
Including tool angular velocity adds the row [1, 1] because the tool angle is θ₁ + θ₂. The two resulting pose columns remain independent: their angular entries agree, but their linear entries differ by a nonzero vector of length L₁. This proves the full planar pose rank stays 2 for this arm.
Separate the achievable request from its residual
Let v* be a requested tip velocity. We seek joint rates that minimize ‖Jθ̇ − v*‖². If several joint-rate vectors achieve the same smallest error, choose the one with the smallest ‖θ̇‖². This is the minimum-norm least-squares solution:
θ̇* = J⁺v*
v_produced = Jθ̇*, r = v* − v_produced
The pseudoinverse equals the inverse when this square J is invertible. At a singularity, JJ⁺v* is the orthogonal projection of the request onto J's column space. The residual is perpendicular to every attainable tip velocity. Its norm reports the missing speed in m/s.
Modern Robotics describes the pseudoinverse's error-minimizing and minimum-length properties in its numerical inverse-kinematics derivation. Here we apply that linear calculation to an instantaneous velocity request.
Both tip coordinates receive equal Euclidean weighting. Both joints are rotational and their rates use the same units. These choices make the stated minimum-norm problem precise. Joint limits, unequal actuator costs, damping, or different weights would define a different optimization problem.
Solve the same request in two configurations
Request v* = (0.5, 0.5) m/s. Begin at θ₁ = 0 and θ₂ = π/2, where the tool is at (2, 1) m:
J = [−1, −1; 2, 0].
The y equation gives 2θ̇₁ = 0.5, so θ̇₁ = 0.25 rad/s. The x equation gives −θ̇₁ − θ̇₂ = 0.5, so θ̇₂ = −0.75 rad/s. These unique rates reproduce both requested components. Their Euclidean norm is approximately 0.790569 rad/s.
Now straighten the elbow. The x equation becomes 0 = 0.5, which no joint rates can satisfy. The y equation is 3θ̇₁ + θ̇₂ = 0.5. Its minimum-norm solution lies along (3, 1):
θ̇* = [0.5 / (3² + 1²)](3, 1)
θ̇* = (0.15, 0.05) rad/s
The produced velocity is (0, 0.5) m/s and the residual is (0.5, 0) m/s. Every vector (0.15, 0.05) + t(1, −3) gives the same produced velocity. The added vector is orthogonal to the chosen solution, so any nonzero t increases the squared joint-rate norm by 10t².
Change the request to (0, 0.5), and the residual becomes zero at the same singular configuration. A successful request does not establish full rank; it may lie entirely in the remaining available direction.
Keep near-singular conditioning separate from rank loss
Set θ₁ = 0 and θ₂ = 0.1°, keeping v* = (0.5, 0.5) m/s. The determinant is nonzero, so the task still has rank 2. Solving the two equations gives approximately:
θ̇* = (143.489303, −429.968346) rad/s.
The joint-rate norm is 453.279118 rad/s. The requested velocity is matched algebraically, but these rates could greatly exceed a physical robot's limits. The almost parallel Jacobian columns must combine through large, partly canceling contributions to create the difficult velocity component.
The singular values quantify this directional behavior. For this square, full-rank position map:
κ₂(J) = σ_max / σ_min, ‖J⁻¹‖₂ = 1 / σ_min
At 0.1°, σ_min ≈ 0.001104 m/rad and κ₂(J) ≈ 2864.788336. Small errors or requests along the weak output direction can demand large joint-rate changes. The exact demand still depends on the requested direction. Modern Robotics connects these directional gains to manipulability.
At exactly zero elbow angle, σ_min becomes zero and the condition number is infinite. The least-squares calculation then leaves the blocked component as a residual. It does not approximate the exploding inverse solution by pretending the elbow angle is small but nonzero.
Rank in this experiment follows the known geometry, with no arbitrary numerical cutoff. In a general measured Jacobian, numerical rank requires a tolerance informed by precision and scale. The manipulability experiment compares velocity directions under an explicit joint-rate budget.
Request a velocity and inspect the result
Start with the regular pose, then compare Straight arm, Near straight (0.1°), and Folded arm. Inspect both the velocity residual and the joint-rate norm. The exact singular cases can have smaller computed rates because they leave part of this request unfulfilled.
Use Tangent request and Blocked request to isolate the achievable and missing components. Rotated straight arm shows that the available line follows the arm's orientation. Zero request confirms that zero rates can satisfy a request without changing the configuration's rank.
The drawing places velocity arrows at the tool. A display scale of one second converts each velocity into a visible length: 1 m/s occupies 1 m on the grid. The arrow endpoint is a drawing endpoint, not a finite-motion prediction. Near a singularity, holding the computed rates for a whole second would radically change the configuration and invalidate the initial Jacobian.
This model assumes rigid links, ideal revolute joints, exact lengths, and instantaneous kinematics. It does not simulate inertia, contact, joint-speed limits, or actuator dynamics. For a controller or a learned policy that outputs Cartesian velocities, those additional constraints determine which requests are usable on hardware.
The joint limits in inverse kinematics lesson puts explicit bounds on a local joint-rate solve. Compare its chosen rates with a clipped unconstrained solution and check the resulting tool-velocity error.
Distinguish robot geometry from orientation coordinates
A configuration singularity of this position task comes from the physical joint-to-tip map. Changing how we store the arm's orientation cannot restore its missing instantaneous position direction.
An orientation-coordinate singularity concerns a representation of rotations. For a roll-pitch-yaw convention, a finite angular velocity can correspond to ill-conditioned or nonunique angle rates near gimbal lock. Drake's roll-pitch-yaw floating-joint documentation identifies its coordinate singularities at pitch π/2 + kπ even though the modeled rigid body can move freely.
The Euler-angle lesson examines that representation issue. Unit quaternions provide another representation of orientation, but switching to them does not repair a physical task Jacobian that has lost rank.
Practical responses depend on the task: reduce the requested speed, change configuration, choose another path, or relax a task component. Damped least squares trades some velocity accuracy for reduced rate amplification. Numerical inverse kinematics develops that connection through repeated finite updates. A zero velocity residual from one unconstrained calculation alone does not certify a feasible trajectory.
Reproduce the velocity calculation in Python
This standard-library example fixes the shoulder at zero and implements the two explicit cases: invertible position map, and rank-one projection. Exact straight and folded presets receive their exact trigonometric values. No general-purpose singular-value solver is needed for these known matrices.
from math import cos, sin, radians, hypot
def attempt(elbow_degrees, requested):
angle = radians(elbow_degrees)
c, s = cos(angle), sin(angle)
singular = elbow_degrees in (0, 180, -180)
if singular:
c, s = (1.0, 0.0) if elbow_degrees == 0 else (-1.0, 0.0)
vx, vy = requested
if singular:
a, b = 2 + c, c
rates = (a * vy / (a*a + b*b), b * vy / (a*a + b*b))
else:
first = (c * vx + s * vy) / (2 * s)
rates = (first, -vx / s - first)
q1, q2 = rates
produced = (-s * (q1 + q2), (2 + c) * q1 + c * q2)
residual = (vx - produced[0], vy - produced[1])
return rates, produced, hypot(*residual)
def pair(values):
return "(" + ", ".join(f"{0.0 if abs(v) < 5e-7 else v:.6f}"
for v in values) + ")"
for label, elbow in [("regular", 90), ("near", 0.1),
("straight", 0), ("folded", 180)]:
rates, produced, error = attempt(elbow, (0.5, 0.5))
print(f"{label}: rates={pair(rates)} rad/s")
print(f" produced={pair(produced)} m/s; residual norm={error:.6f} m/s")
Expected output:
regular: rates=(0.250000, -0.750000) rad/s
produced=(0.500000, 0.500000) m/s; residual norm=0.000000 m/s
near: rates=(143.489303, -429.968346) rad/s
produced=(0.500000, 0.500000) m/s; residual norm=0.000000 m/s
straight: rates=(0.150000, 0.050000) rad/s
produced=(0.000000, 0.500000) m/s; residual norm=0.500000 m/s
folded: rates=(0.250000, -0.250000) rad/s
produced=(0.000000, 0.500000) m/s; residual norm=0.500000 m/s
The near-singular residual contains tiny floating-point error before formatting. The example reports six decimals and makes no finite integration step.
Try it yourself
Exercise 1. Fold the elbow to π with the shoulder at zero. Request (−0.4, 0.6) m/s. Find the minimum-norm joint rates, produced velocity, residual, and residual norm.
Show the folded-arm solution
Here J = [0, 0; 1, −1]. The available y equation is θ̇₁ − θ̇₂ = 0.6. Its minimum-norm solution is (0.3, −0.3) rad/s, found by multiplying (1, −1) by 0.6/2.
The produced velocity is (0, 0.6) m/s. Subtracting it from the request gives residual (−0.4, 0) m/s, whose norm is 0.4 m/s. These rates have zero tool angular velocity because they sum to zero, but the tool's position is moving.
Exercise 2. At the straight configuration θ₁ = θ₂ = 0, choose joint rates (1, −3) rad/s. Calculate tip velocity and tool angular velocity. Does zero instantaneous tip velocity imply that holding those rates keeps the tip fixed for a finite interval?
Show the null-motion solution
The position Jacobian gives ṗ = (0, 3 × 1 − 3) = (0, 0) m/s. The tool angular velocity is 1 − 3 = −2 rad/s. The rates lie in the position task's null space, while producing nonzero full-pose motion.
After holding these rates for time t, the angles become θ₁ = t and θ₂ = −3t, with radians understood. The exact x coordinate is 2 cos t + cos(−2t). Its small-time expansion is 3 − 3t² + O(t⁴), so the tip begins moving inward at second order. Zero initial position velocity does not keep its finite position fixed.
Sources and further study
- Modern Robotics, 5.3: Singularities defines rank loss relative to attainable rank and compares planar velocity directions across configurations.
- Modern Robotics, 5.4: Manipulability develops directional velocity gains and measures derived from a Jacobian's ellipsoid.
- Modern Robotics, 6.2: Numerical Inverse Kinematics, Part 1 derives local pseudoinverse updates and explains their least-squares and minimum-length properties.
- Drake: RpyFloatingJoint documentation distinguishes free rigid-body motion from singular roll-pitch-yaw coordinates.