Robots near a singularity: what does the damped inverse sacrifice?

Abstract. Near a singularity, a small requested tool velocity can require enormous joint velocities. A damped Jacobian inverse keeps the gain finite, but changes the motion actually produced. This study quantifies the trade-off using a planar two-joint manipulator: kinematic derivation, regularized solution, spectral interpretation and reproducible calculation. Its central distinction is that limiting numerical amplification does not restore lost mobility, enforce every actuator constraint or demonstrate robot safety.

Readers should be familiar with derivatives, vectors and least squares. The deliberately small example lets us check every step and understand what the numerical procedure sacrifices. We present neither hardware tests nor a new algorithm; the educational experiment was executed in Python with NumPy in double precision.

1. A request that looks harmless only in Cartesian space

Imagine a tool commanded to move horizontally at one centimetre per second. The request looks modest, but feasibility depends on the arm configuration. When two links are almost aligned, moving the tip along their axis requires large, opposing joint rotations. In a bent configuration, the same velocity can be obtained without this amplification.

A controller often receives a Cartesian command from planning, vision, teleoperation or a learned policy. The semantic correctness of that command does not ensure a well-conditioned kinematic inversion. This is one interface between AI and robotics: translating an intention into motion compatible with current geometry. Our precise question is: how much Cartesian error do we incur when damping reduces joint velocities?

2. Building the problem: a 2R arm

Consider two rigid links of lengths l1 and l2 and two revolute joints. q1 measures the first link angle relative to the base x-axis; q2 is relative to the first link. All angles inside trigonometric functions are in radians. We study only the planar tip position, not its orientation. Forward kinematics gives:

x = l1 cos(q1) + l2 cos(q1 + q2)
y = l1 sin(q1) + l2 sin(q1 + q2)
v = J(q) qdot

Differentiating with respect to each angle gives a 2×2 matrix. Each column describes the tip velocity produced by unit velocity of its corresponding joint:

J = [ -l1 sin(q1)-l2 sin(q1+q2)   -l2 sin(q1+q2) ]
    [  l1 cos(q1)+l2 cos(q1+q2)    l2 cos(q1+q2) ]
det(J) = l1 l2 sin(q2)

The determinant vanishes when q2 is zero or a multiple of π. With both links extended along x, the columns of J are vertical: to first order, no combination of joint velocities produces horizontal velocity. This is not a computer precision defect; it is a geometric loss of instantaneously available directions.

This relationship is local. It does not say that the tip can never reach an interior position after a finite manoeuvre. It says that the differential model cannot produce an x-component at that instant. An algorithm returning that component exactly without changing assumptions would be solving a different problem.

3. Why the pseudoinverse amplifies the command

The singular value decomposition writes J = UΣVᵀ. Columns ui of U are orthogonal Cartesian directions; columns vi of V are joint-space directions. σi indicates how much Cartesian motion unit joint velocity along vi produces. The pseudoinverse applies gain 1/σi to reachable components. For zero σi it uses zero, returning the minimum-norm least-squares solution. This classical framework and its damped alternative are discussed in sections 4–6 of the technical note by Samuel R. Buss.

qdot_pinv = Σi:σi>0 vi (uiᵀ v) / σi

For our example choose l1 = l2 = 1 m, q1 = 0 and v = (0.01, 0) m/s. For q2 different from zero and π, the system can be solved without a library: its second row relates the joint velocities; substituting into the first gives qdot1 = 0.01 cot(q2) and qdot2 = −0.01 cot(q2/2), in rad/s. For small q2, their norm therefore grows approximately as 0.01√5/|q2|.

At 0.1 degrees this predicts a norm of about 12.81 rad/s despite a command of only 0.01 m/s. At exactly zero degrees, however, the pseudoinverse returns zero joint velocities for this horizontal command. The value at the singular point is not the limit of nearby values. A numerical threshold that truncates singular values avoids some divisions, but introduces an operational choice about switching between those behaviours.

4. Deriving the damped inverse

Introduce an unknown joint vector z and positive penalty parameter λ. In our units, J has dimension m/rad and λ uses the same scale. We minimize a strictly convex function:

L(z) = ||Jz − v||² + λ² ||z||²
∇L(z) = 2 Jᵀ(Jz − v) + 2λ²z
(JᵀJ + λ²I) z = Jᵀv
qdot_DLS = (JᵀJ + λ²I)⁻¹ Jᵀv

The normal-equation matrix is positive definite for λ > 0: along every nonzero vector its quadratic form is ||Jz||² + λ²||z||², which is positive. A unique minimum therefore exists even when J loses rank. The formula helps reasoning; in code one should solve the system or use the SVD instead of explicitly forming an inverse.

Substituting the SVD and using orthogonality separates the problem into independent coordinates. Each joint coordinate pays for both the residual along one Cartesian direction and its own magnitude. The scalar solution changes the gain from 1/σ to σ/(σ²+λ²). Here “damping” means kinematic regularization: we are neither adding a mechanical damper nor modelling physical dissipation.

5. The price of damping, direction by direction

gλ(σ) = σ / (σ² + λ²)
J qdot_DLS = Σi ui [σi²/(σi²+λ²)] (uiᵀv)
r = v − J qdot_DLS
gλ'(σ) = (λ² − σ²) / (σ²+λ²)²
maxσ≥0 gλ(σ) = 1/(2λ)
||qdot_DLS|| ≤ ||v||/(2λ)

Achieved velocity is attenuated more strongly in directions with small σ. At σ = λ exactly half of the requested component passes through; when σ greatly exceeds λ, attenuation becomes small; at zero σ the component remains impossible. Differentiating the gain shows that its maximum occurs at σ = λ. Orthogonality and the operator spectral norm then give the joint-velocity bound.

With ||v|| = 0.01 m/s and λ = 0.05 m/rad, the joint norm cannot exceed 0.1 rad/s in this model. This is a sufficient bound on the whole vector, not a check of accelerations, torques, collisions or position limits. If joints have different limits, one λ does not directly express those priorities. Specific constraints must be formulated explicitly, for example in a constrained quadratic optimization problem.

The penalty also does not remove only “bad” motion. Finite λ attenuates well-conditioned directions too, albeit less. A very large λ gives small velocities everywhere: a low joint-velocity norm alone is not evidence of successful task execution.

6. Reproducible experiment: fixed geometry, no physical robot

We calculated solutions at q2 values of 30°, 10°, 1°, 0.1° and 0°, keeping the link lengths and command defined above. The program uses float64 SVD; for the pseudoinverse it treats singular values no greater than 10⁻¹² as zero. Damping values are 0.01 and 0.05 m/rad. There is no random sampling, training or time integration: each row is an independent configuration.

The almost-zero pseudoinverse residuals are rounding errors, not experimental measurements from the physical world. The one-degree comparison is revealing: λ = 0.05 reduces joint norm by about forty-two times relative to the pseudoinverse, but the residual reaches about 97.6% of the command norm. The ideal robot barely performs the requested motion. Reporting only the velocity reduction would therefore be misleading.

The upper plot also shows non-monotonic DLS behaviour: gain rises toward the critical region and then decreases toward zero in the direction losing mobility. The lower plot exposes the cost of that reduction. Showing both prevents mistaking stopped motion for accurate task execution.

7. Essential code and independent checks

import numpy as np
q2 = np.deg2rad(1.0)
J = np.array([[-np.sin(q2), -np.sin(q2)],
              [1 + np.cos(q2), np.cos(q2)]])
v = np.array([0.01, 0.0])
lam = 0.05
U, sigma, Vt = np.linalg.svd(J, full_matrices=False)
qdot = Vt.T @ ((sigma / (sigma**2 + lam**2)) * (U.T @ v))
print(np.linalg.norm(qdot), np.linalg.norm(v - J @ qdot))

The archive includes the complete program, results and plotting script. The Jacobian check compares the formula with centred finite differences using a 10⁻⁶ rad step at a nonsingular configuration. A second check evaluates the normal-equation residual for DLS solutions; a third verifies the norm bound and invariance under consistent conversion from metres to millimetres. These are different checks: no single one proves the entire implementation, but together they catch sign, scale and solution errors.

Download code, data and reproduction instructions. The results file also contains velocity components and singular values, so verification need not stop at aggregate norms.

8. A number without units can change the controller

Expressing the same lengths in millimetres multiplies J and v by one thousand. To preserve the solution, λ must also be multiplied by one thousand: the entire objective is then multiplied by one million. Keeping λ = 0.05 after changing units instead makes the relative penalty one million times smaller. This is not a display detail; it changes the calculated motion.

The issue grows in spatial robots when linear and angular velocities are combined. A norm that adds components in m/s and rad/s incorporates a weighting choice. Before comparing condition numbers, damping parameters or accuracy, one must define a consistent metric, for instance normalizing by position and orientation scales relevant to the task. There is no universally transferable λ without that convention.

9. From kinematics to control: what is missing

A real loop integrates the command, acquires fresh measurements and recomputes J. It introduces a sampling period, delays, model errors, saturation and actuator dynamics. We chose no sampling period here because we do not simulate that loop. Inferring closed-loop stability from a finite matrix would be a logical leap. Even a small velocity norm can conceal rapid changes between samples.

An operational comparison should record Cartesian error, per-joint velocity and acceleration, saturation and distance to constraints, as well as computation time. Methods should be tested on the same trajectory with identical unit conventions and limits. Before that, the requested trajectory itself may need modification: not every Cartesian command must be pursued at any cost.

Recent research also explores alternatives to uniform regularization. The preprint J-PARSE, version 1 from 2025, distinguishes singular and nonsingular directions and modifies the command through projections. Sections III and IV describe the method, simulation comparisons and physical demonstrations; joint limits and collisions are explicitly outside the formulation addressed. We did not reproduce that study, and our numbers are not a comparison with J-PARSE. It is a research direction, not proof of universal superiority.

10. Implications for robotics and AI in businesses

A learned system proposing a pose or velocity must coexist with an execution layer that exposes what it can achieve. In this example, DLS could return achieved velocity and residual alongside the joint command: the planner would learn that almost all requested motion was lost. That feedback may justify a different configuration or slowing the task. This is an architectural proposal derived from the calculation, not a feature already tested in production.

Industrial and collaborative robotics is a stated direction of interest for EL-AI. This study clarifies a technical issue relevant to that direction without attributing nonexistent installations, controllers or physical tests to the company. The experiment is educational and does not validate the safety of a collaborative cell.

Conclusion. The damped inverse controls inversion gain by accepting a direction-dependent residual. What matters is not only how much joint velocities fall, but how much of the command is actually achieved. Near full extension the trade-off can be extreme: a numerically calm solution can correspond to a nearly stationary tool.

Sources and transparency

Buss, Introduction to Inverse Kinematics with Jacobian Transpose, Pseudoinverse and Damped Least Squares Methods, technical note, sections 4–6; J-PARSE, arXiv:2505.00306v1, 2025, sections III–IV. Sources are linked at relevant points and were consulted on 22 September 2026. The 2R derivation, calculations and figures are reproducible educational material, not a new peer-reviewed publication.

Text and translations prepared with AI assistance; no human review is claimed. The AI-generated cover is illustrative and does not depict a real EL-AI installation.