Constraint embedding

Overview

A mechanism with closed kinematic loops has joint variables that must satisfy loop-closure constraints at every instant, so the joints cannot all be chosen freely. Constraint embedding handles this loop by loop: each fundamental cycle is solved numerically inside its own limb, and the limb is then described by a set of independent coordinates q 2412.13638 §3.4. The loop's joint variables are split into dependent variables y, whose Jacobian block is square and invertible, and independent variables q 2412.13638 §3.4, eq. 16.

The invariant shared by all variants: the loop constraints hold at every configuration the solver returns, and the rest of the model (kinematics, Jacobians, equations of motion) is written in q only, with rates related through a matrix H 2412.13638 eq. 17. Each loop is solved independently of the others, which is what makes the embedding local 2412.13638 §3.4.

The method is shown for parallel kinematic manipulators, where several limbs hold one platform, and each limb can contain closed loops in series 2412.13638 §2.

Variants

Only one paper with a card is currently linked to this concept, so the variants below are different solver schemes from the same paper, plus the alternatives it argues against.

Nested inverse kinematics with a local loop solver

Limb inverse kinematics is an outer iteration. For a pose error, it computes an increment in the independent coordinates, Δq = F_t Δx_t, applies it, and re-solves the loops with an inner Newton correction on the dependent variables until the loop residual is below ε [arxiv:2412.13638 alg. 1, alg. 2, eq. 31]. On the IRSBot-2 example at a 1 ms time step, the paper reports 1 to 3 outer and 1 to 3 inner iterations per step [arxiv:2412.13638 §6.4.1, fig. 11, fig. 12]. Card: Mueller, hybrid-limb constraint embedding.

Compound iteration

The compound scheme performs one linearised step on all joint variables per outer iteration, Δθ = H F_t P_t (I − ΔC_p)^∨, and leaves the loop residual to the stopping test only 2412.13638 alg. 3, §4.2. In the paper's example it needs about three iterations per time step, and its total cost is about the same as the nested scheme 2412.13638 §6.4.1, fig. 15, fig. 16. The paper justifies this scheme only for regular loop constraints, and it has no explicit correction of the loop constraints 2412.13638 §6.4.1. Card: Mueller, hybrid-limb constraint embedding.

Alternatives the paper argues against

• Whole-robot constraint set. Standard multibody formulations impose all cut-joint constraints of the robot at once. For many lower-mobility parallel robots this set is redundant, which makes the model large and numerically awkward 2412.13638 §1, §4.3.
• Equivalent joint replacement. A loop can be replaced by a kinematically equivalent joint, for example a one-DOF Π-joint for a parallelogram. The paper notes that this hides internal singularities and drops the dynamics of the loop members, so non-symmetric mass distributions and joint reactions cannot be represented 2412.13638 §1.

When to use which

The rows below restate what the paper's example and its stated assumptions support. Results are author-reported on one example with no error figures 2412.13638 §6.4.

Implementation sketch

The core is the same in both schemes: solve the loops locally for a given change in q, then iterate the limb inverse kinematics on the pose error. The pseudocode below follows the paper's Algorithms 1 and 2. Variants differ in whether the loops are re-solved to tolerance inside each outer step (nested) or only once per step (compound) 2412.13638 alg. 1, alg. 2, alg. 3.

# Local loop solver for one fundamental cycle  [alg. 2]
# Input: theta (dependent y, independent q), delta_q, tolerance eps
# Output: theta that satisfies the loop constraints

def solve_loop(theta, delta_q, eps):
    # Move the independent coordinates by delta_q  [alg. 2]
    # Take one linearised step for the dependent ones  [alg. 2]
    # Jacobians are evaluated at the input configuration  [alg. 2]
    ...
    # Newton corrections on the dependent coordinates until the residual
    # is below eps  [alg. 2, §4.1.2]
    ...
    return theta

# Limb inverse kinematics with loop constraints  [alg. 1]
# Input: theta_0 (admissible), target pose C_p, eps
# Output: theta of the limb at the target pose

def limb_inverse_kinematics(theta_0, target_pose, eps):
    # Start from an admissible configuration  [alg. 1]
    theta = theta_0
    error = pose_task_error(theta, target_pose)
    while norm(error) > eps:
        # Increment in the independent coordinates  [eq. 31]
        # F_t is evaluated at the current configuration  [alg. 1, alg. 3]
        delta_q = F_t(theta) @ error
        # Re-solve the loops for the new independent coordinates  [alg. 2]
        theta = solve_loop(theta, delta_q, eps)
        error = pose_task_error(theta, target_pose)
    return theta

Notes on where the implementation choices matter:

• The choice of independent coordinates for each loop sets the conditioning of G_y and H, and the paper says it is not unique 2412.13638 §3.4.
• The solution is only valid near the starting configuration. Switching coordinates or constraint parameterisations between motion modes may be needed, but the paper gives no switching procedure 2412.13638 §3.4, §4.1.2.
• The stopping tests use a left-invariant norm on SE(3) with weights α and β, which the paper does not state. Both stopping tests depend on them 2412.13638 §4.1.1.
• In the paper's example, the time step for inverse kinematics was 1 ms and the one for inverse dynamics 10 ms 2412.13638 §6.4.1.

Contradictions

Between papers: none known, since only one card cites this concept. Within that paper, the example's dimensions disagree: §6.1 gives L_1 = 1/4 m and L_2 = 1/2 m, while §6.4.2 gives L_1 = 1/2 m and L_2 = 3/4 m 2412.13638 §6.1, §6.4.2. Do not resolve this by picking one value without checking the source.

Papers

• Mueller, hybrid-limb constraint embedding: solves each closed loop numerically inside its limb, with nested and compound inverse-kinematics schemes and a task-space dynamics model for feedforward control.