Inverse kinematics (IK)

Overview

Inverse kinematics (IK) finds the joint values, or joint velocities, that move a body to a target pose. The five cards solve it in four ways. One is a velocity-level solve through a task Jacobian, posed as a QP 2411.07534 §II. Another is a Jacobian-based update applied to a limb whose closed loops have been reduced to a local map 2412.13681 §3.3.2 2412.13681 §4.1. The third is a Newton-type iteration that re-solves the loop constraints at each step 2412.13638 alg. 1 2412.13638 alg. 2. A fourth card treats IK for a legged robot as a position-based numerical solve 2403.15993 §VII. A fifth card, for high-DoF humanoids and arms, runs a batched Levenberg-Marquardt solve on a GPU, then an L-BFGS pass that removes collisions 2603.05493 §6.1.3.

The shared core is a linearised update. A Jacobian maps a change in joint values to a change in the task, and the update is chosen to reduce the task error 2411.07534 §II 2412.13681 §4.1 2603.05493 alg. 3. The variants differ in how they handle redundancy, closed loops and collisions.

The five cards are all draft-stage compilations of author-reported work. Four of them report no comparison against another IK method on the same robot. The fifth compares its IK with Newton, PyRoki and cuRobo on a 48-DoF humanoid 2603.05493 §7.4. Those are the authors' own runs, and the card does not reproduce them, so the choice between variants should rest mainly on constraints.

Variants

QP velocity IK with soft collision barriers

The problem is a humanoid with more joints than the operator's trackers. Each tracker's task Jacobian is masked to its assigned joints, J_m = J S, so each tracker drives a fixed joint group 2411.07534 §II 2411.07534 eq. 2. The joint velocities come from a QP that sums a weighted task error, a regularizer per task, and a relaxed-barrier term per collision pair 2411.07534 §II 2411.07534 eq. 3. The barrier is a soft constraint, so the solver returns a best-effort motion instead of rejecting a colliding command 2411.07534 §II. The card states that the barrier is expanded to second order in the joint velocity, which removes the need for an inequality step in most QP solvers 2411.07534 §II 2411.07534 eq. 4. Gains, task weights and the regularizer's form are not stated, and results are qualitative only, with no baselines 2411.07534 §IV. Card: VR teleoperation of an upper-body humanoid.

Closed-form loops with a Jacobian map (parallel limbs)

For a parallel manipulator whose limbs contain closed loops, each loop is reduced to a local map. The dependent rates follow from the independent ones through a block split, and these are stacked into one matrix H, so that all joint rates are H times the independent rates 2412.13681 §3.3.2. For a non-redundant limb with a square task Jacobian L_t, the independent rates are F times the task twist, where F is the inverse of L_t 2412.13681 §4.1. If a limb has no closed-form IK, the card iterates a Jacobian step, Δθ = H F Δx, with H and F re-evaluated at each configuration 2412.13681 §4.4. The worked Delta example reports 2.74 µs for IK plus inverse dynamics on one node, and 0.97 µs for the slowest limb when the three limbs run on separate nodes. These timings come from one PC and exclude inter-node communication 2412.13681 §9.4 2412.13681 tab. 1. The card notes that its example section says closed-form IK is not used, yet the same section uses a closed-form loop solution 2412.13681 §9.1. Card: Modular dynamics of parallel manipulators.

Nested Newton loop solver (constraint embedding)

Here the closed loops are solved numerically, inside the IK loop. The outer step takes an increment in the independent coordinates, Δq = F_t Δx_t. Then each loop is re-solved with Newton corrections on its dependent coordinates until the loop residual is below a tolerance 2412.13638 alg. 1 2412.13638 alg. 2 2412.13638 eq. 31. A compound variant does one loop step per outer iteration, which saves inner work. The card justifies that variant only for regular loop constraints 2412.13638 alg. 3 2412.13638 §6.4.1. On one limb of the IRSBot-2 with a tolerance of 1e-10, the card reports 1 to 3 outer iterations per step at a 1 ms sampling step, and 3 almost always at 10 ms 2412.13638 §6.4.1 2412.13638 fig. 11. Near the input singularity the inner loop needs at most 2 iterations 2412.13638 §6.4.3. The model is validated against a commercial multibody tool, but the card reports no error metric 2412.13638 §6.4. The solution is only local: the iteration is valid near the starting configuration 2412.13638 §4.1.2. Card: Constraint embedding for parallel kinematic manipulators.

Position-based numerical IK with a learned collision check (legged robots)

A biped's full-body joint angles are found by a numerical, position-based IK. It is driven by the swing-foot and centre-of-mass positions, with an upright body, zero hip yaw, flat toes and spring and loop-closure constraints. The measured joints serve as the initial guess 2403.15993 §VII. Exact self-collision checks need this iterative IK, which the card describes as too slow to run inside an MPC. The authors instead train one small network per capsule pair on the reduced-order state, with a stated maximum error of 0.03 m and a mean error of 0.002 m 2403.15993 §VI-C. The networks evaluate above 1 MHz, against under 1 kHz for the iterative route 2403.15993 §VI-C. A consistency check over 5000 inputs and 200 initial guesses per input reports an error of about 3×10⁻⁸ 2403.15993 §VIII-A. The training details (activation, optimiser, epochs) are not stated 2403.15993 §VI-C. Card: Robust locomotion by logic for a biped.

Batched Levenberg-Marquardt IK with L-BFGS collision removal (high-DoF robots)

For high-DoF systems the card solves IK on a GPU, in batches of problems. A Levenberg-Marquardt step with a trust region first reaches the target pose without collision constraints. The step is accepted or rejected by comparing the actual error reduction with the predicted one. A rejected step raises the damping, and an accepted one lowers it 2603.05493 §6.1.3 2603.05493 alg. 3. A second stage, L-BFGS, then adds the self-collision and scene-collision terms 2603.05493 §6.1.3. The Jacobian is built sparsely, with one thread per joint and a coarse table of which joints affect which links 2603.05493 alg. 2. On a 48-DoF humanoid at batch size 100, the card reports 100% success and 0.96 µm position error for standard IK in 34 ms. For self-collision-free IK it reports 99.6% success in 533 ms 2603.05493 §7.4 2603.05493 fig. 15. The damping bounds, trust-region constants and L-BFGS settings are not stated 2603.05493 alg. 3. The card's source paper is a larger motion stack, so the IK numbers are one part of its results 2603.05493 §1. Card: cuRoboV2: Dynamics-Aware Motion Generation with Depth-Fused Distance Fields for High-DoF Robots.

When to use which

Both Mueller variants assume non-redundant limbs for inverse kinematics 2412.13638 §3.6 2412.13681 §4.1. Any implementation that goes beyond that must take the redundant case from another source.

Implementation sketch

The common core of the loop-constrained variants, with the loop solve as a separate step. The QP variant replaces the update line with the weighted cost of 2411.07534 eq. 3.

# Loop-constrained inverse kinematics, one limb  [arxiv:2412.13638 alg. 1]
# Input:  joint state q, target pose, tolerance eps
# Output: joint state at the target pose
def inverse_kinematics(q, target, eps):
    # Task error from the pose mismatch  [arxiv:2412.13638 alg. 1]
    error = task_error(q, target)
    while norm(error) > eps:
        # Independent increment from the task Jacobian  [arxiv:2412.13638 eq. 31]
        dq = F(q) @ error
        # Re-solve the closed loops for the new coordinates  [arxiv:2412.13638 alg. 2]
        q = solve_loops(q + dq, eps)
        error = task_error(q, target)
    return q

# Quadratic approximation of a relaxed barrier, per collision pair  [arxiv:2411.07534 eq. 4]
# Input:  signed distance h, its gradient dh_dq, barrier B
# Output: scalar cost in the joint velocity dq
def barrier_cost(h, dh_dq, dq):
    # Value, linear and curvature terms from B and its derivatives  [arxiv:2411.07534 eq. 4]
    value = B(h)
    linear = dB_dh(h) * dot(dh_dq, dq)
    curvature = d2B_dh2(h) * dot(dh_dq, dq) ** 2
    return value + linear + 0.5 * curvature

Contradictions

No direct contradictions between the five cards on the IK method itself. Points of difference, not disagreements:

• The two Mueller cards solve the loops differently for their examples. The Delta example uses a closed-form loop solution 2412.13681 §9.1. The IRSBot-2 limb solves its distal loop numerically, and solves its proximal loop by hand 2412.13638 §6.2 2412.13638 §6.4.1.
• Their timing and iteration figures come from different robots, one from a Delta example with two IK iterations and one from a 2-DOF example with 1 to 3 outer iterations, so the numbers should not be compared directly 2412.13681 §9.4 2412.13638 §6.4.1.
• The GPU card's timings are for batches of 100 problems on a 48-DoF humanoid, a different setting from both Mueller timings. They should not be compared with them directly 2603.05493 §7.4 2412.13681 §9.4.

Papers

• VR teleoperation of an upper-body humanoid: QP velocity IK with soft relaxed-barrier collision terms, for a 17-DoF humanoid driven by four VR trackers.
• Modular dynamics of parallel manipulators: Jacobian-based IK through local loop maps for parallel limbs, with per-step timings on a Delta example.
• Constraint embedding for parallel kinematic manipulators: nested Newton-type IK with a numerical loop solver and a compound variant, on a 2-DOF example.
• Robust locomotion by logic for a biped: position-based numerical IK for a biped, and learned networks in place of iterative IK for self-collision checks.
• cuRoboV2: batched GPU Levenberg-Marquardt IK with L-BFGS collision removal, inside a stack that also covers trajectory optimisation and distance fields. Its official code is NVlabs/curobo, under Apache-2.0.