chiaverini1997singularity

Singularity-Robust Task-Priority Redundancy Resolution for Real-Time Kinematic Control of Robot Manipulators

Authors: Chiaverini · Year: 1997 · Venue: IEEE Transactions on Robotics and Automation
Raw: md

Summary

This paper treats the two species of singularity that afflict task-priority redundancy resolution at the inverse-differential-kinematics level: kinematic singularities (rank loss of the end-effector Jacobian) and algorithmic (a.k.a. artificial) singularities, which arise when the secondary-task null-space-projected Jacobian loses rank even though both task Jacobians are individually full rank. It first studies how existing singularity-robust inverses (damped least-squares, numerical filtering) behave when carried over to redundant arms, quantifying the reconstruction error via the SVD. It then proposes a new task-priority law (Eq. 34) that decouples algorithmic singularities from the singularities of the constraint Jacobian and avoids inverting the ill-conditioned matrix J_C(I - J_E^† J_E), yielding continuous joint velocities, accurate primary-task tracking, and lower flop count. The method is validated on a 7-DOF human-arm-like manipulator.

Key Claims

• An algorithmic singularity occurs iff N(J_C) ∩ N(J_E) ≠ {0} (equivalently R(J_Cᵀ) ∩ R(J_Eᵀ) ≠ {0}), with both J_C and J_E full rank (Eqs. 21-23). These are hard to predict in advance because they depend on how the end-effector trajectory conflicts with the constraint task along the path.
• The classic task-priority solution (Eq. 8) and the proposed solution (Eq. 34) coincide both when the secondary task is compatible with the primary task and when it is incompatible (where both reduce to the minimum-norm solution J_E^† ẋ_E). They differ only near algorithmic singularities.
• Behavioral contrast near an algorithmic singularity: Eq. 8 increases the null-space velocity to keep tracking the about-to-be-infeasible constraint component (causing ill-conditioning and large joint velocities), whereas Eq. 34 progressively reduces that null-space velocity component (Eq. 38). The trade is robustness at the cost of secondary-task accuracy.
• Eq. 34 decouples algorithmic singularities from singularities of J_C; one may freely substitute a damped least-squares inverse J_C* for J_C^† (Eq. 39) without entangling the two singularity mechanisms.
• Damped least-squares with numerical filtering (Eq. 16-19) is the recommended compromise: as accurate as the pseudoinverse far from and very close to a kinematic singularity, while remaining continuous and well-conditioned through the transition. Multiple simultaneous singularities require added isotropic damping β² with β² ≪ λ² (Eq. 20).
• Computational advantage: for the n=7, m=6 case, solution (8) needs 796 flops vs. 632 for solution (34) (minimum-norm baseline 519). For m=3 the gap widens to 1212 vs. 760 (baseline 572).
• In closed-loop inverse kinematics (Eqs. 44-48), the DLS task-priority law (45) could not run with significant feedback gains because its primary-task reconstruction error builds up through feedback; the proposed law (46) tolerated high gains (K_E = 1000·I, K_C up to 2000).

Method

Inverse differential kinematics on the redundant mapping ẋ_E = J_E(q) q̇ (Eq. 1), with J_E ∈ R^{m×n}, m < n. The SVD J_E = U Σ Vᵀ = Σ_{i=1}^r σ_i u_i v_iᵀ (Eq. 2) is the analytic workhorse throughout.

Baseline redundancy resolution via pseudoinverse with null-space term:
q̇_PI = J_E^† ẋ_E + (I - J_E^† J_E) q̇_0 (Eq. 4).

Task-priority (secondary task ẋ_C = J_C q̇, Eq. 6) classically solves for q̇_0 minimizing constraint reconstruction error:
q̇ = J_E^† ẋ_E + (J_C(I - J_E^† J_E))^† (ẋ_C - J_C J_E^† ẋ_E) (Eq. 8).

For kinematic singularities, the damped least-squares inverse J_E* = J_Eᵀ(J_E J_Eᵀ + λ²I)^{-1} = Σ σ_i/(σ_i²+λ²) v_i u_iᵀ (Eq. 11) trades reconstruction error for conditioning. A variable damping factor confines damping to a singular region:
λ² = 0 for σ_m ≥ ε; λ² = (1 - (σ_m/ε)²) λ_max² for σ_m < ε (Eq. 15). Numerical filtering damps only the degenerate direction: J_E° = J_Eᵀ(J_E J_Eᵀ + λ² u_m u_mᵀ)^{-1} (Eq. 16).

The new contribution rederives the null-space term. Substituting (4) into (6) and noting the equality can hold only on R(J_C), the author relaxes to J_C J_C^† ẋ_C = ... (Eq. 30), which is implied by the simpler J_C^† ẋ_C = J_E^† ẋ_E + (I - J_E^† J_E) q̇_0 (Eq. 31). Solving gives q̇_0 = (I - J_E^† J_E) J_C^† ẋ_C (Eq. 33), hence the proposed law:

q̇ = J_E^† ẋ_E + (I - J_E^† J_E) J_C^† ẋ_C (Eq. 34).

Intuition: solve each task independently with its own pseudoinverse, then project the constraint solution onto N(J_E) to strip interference before summing. Efficient real-time form: solve H w = ẋ_E - J_E q̇_0 (Cholesky-factorable, positive definite for DLS variants), then q̇ = J_Eᵀ w + q̇_0 (Eqs. 42-43).

Regime: This is a fixed-base industrial manipulator paper (7-DOF human-arm-like arm). It is neither free-flying nor free-floating — the base is grounded and there is no dynamic base-manipulator coupling. The relevance to free-flying space manipulators is by transfer of the redundancy-resolution and singularity-robust-inverse machinery, not by any spacecraft-specific modeling. For a free-flying base, J_E would be the (generalized) Jacobian mapping the augmented base+joint velocities to end-effector velocity; the kinematic vs. algorithmic singularity distinction and the DLS/null-space remedies carry over directly to that setting.

Relevance to thesis

The kinematic vs. algorithmic singularity taxonomy and the damped/filtered pseudoinverse remedies are foundational for any prioritized multi-task controller on a free-flying space manipulator (e.g., end-effector trajectory as primary, base-attitude or obstacle/inspection constraints as secondary). Eq. 34’s decoupling of algorithmic singularities from constraint-Jacobian singularities, plus its closed-loop friendliness and lower flop count, make it a strong candidate for the nominal prioritized guidance layer before any risk-aware extension. The SVD-based reconstruction-error bookkeeping (Eqs. 10, 14, 19) gives a principled way to reason about exactly which task-velocity components become infeasible near singularities — directly useful when later attaching uncertainty/chance constraints to feasible-velocity directions.

Connections

Topics: algorithmic_singularity · damped_least_squares · task_priority_redundancy_resolution · kinematic_singularity

Key Equations / Quotes

“An algorithmic singularity occurs whenever N(J_C) ∩ N(J_E) ≠ {0}” (p. 3, Eq. 21).

“correct primary-task solutions are expected as long as the sole primary-task Jacobian matrix is full-rank.” (Sec. I)

Proposed law (Eq. 34):

q̇ = J_E^† ẋ_E + (I - J_E^† J_E) J_C^† ẋ_C

Damped least-squares inverse (Eq. 11):

J_E* = J_Eᵀ(J_E J_Eᵀ + λ²I)^{-1} = Σ_{i=1}^r [σ_i/(σ_i²+λ²)] v_i u_iᵀ

Variable damping in singular region (Eq. 15):

λ² = 0 if σ_m ≥ ε; λ² = (1 - (σ_m/ε)²) λ_max² if σ_m < ε

Near-singularity behavior (Eq. 38):

(I - J_E^† J_E) J_C^† = Σ_{i=1}^{n-m} Σ_{j=r+1}^{n} [(v_{C,i}ᵀ v_j)/σ_{C,i}] v_j u_{C,i}ᵀ

Open Questions

• The proposed law (34) sacrifices secondary-task tracking accuracy near algorithmic singularities (joint 5 “does not move almost at all” in Case A); the paper does not characterize a bound on the resulting steady-state constraint error as a function of singularity proximity.
• Case B shows a residual steady-state end-effector position error tied to using J_E* in the null-space filter of (46), dependent on λ — no design rule is given for choosing λ to bound this error.
• Extension to a hierarchy of more than two priority levels is not treated; how the decoupling property of (34) generalizes to deeper task stacks is left open.
• No dynamic-level (torque) or floating/flying-base treatment; how the velocity-level analysis interacts with base-manipulator dynamic coupling is outside scope.