---
kind: concept
slug: constraint-embedding
title: Constraint embedding
summary: >-
  Handling closed kinematic loops in a mechanism by solving each loop's constraints numerically inside its own limb, so that the limb acts as an ordinary serial chain in independent coordinates. The trade-off: the local solver needs well-conditioned loop Jacobians and regular, non-redundant constraints, and the only evidence so far is one author-reported two-DOF example.
tags: [kinematics, dynamics, parallel-manipulators, closed-kinematic-chain]
papers: ["2412.13638"]
related: []
status: draft
updated_at: 2026-10-25
---

## 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 [arxiv: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 [arxiv: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 [arxiv:2412.13638 eq. 17]. Each loop is solved independently
of the others, which is what makes the embedding local
[arxiv: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
[arxiv: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](/papers/2412.13638).

### 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 [arxiv: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 [arxiv: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
[arxiv:2412.13638 §6.4.1]. Card: [Mueller, hybrid-limb constraint embedding](/papers/2412.13638).

### 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 [arxiv: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 [arxiv: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
[arxiv:2412.13638 §6.4].

| Situation | Use | Why |
|---|---|---|
| Loops are regular at the working configuration (square, invertible G_y) and you want the loop residual enforced explicitly | Nested scheme | Each outer step re-solves the loops with Newton corrections [arxiv:2412.13638 alg. 2] |
| Loops are regular and you prefer one linearised step per time step | Compound scheme | Same total cost as nested in the example, but no explicit constraint correction [arxiv:2412.13638 §6.4.1] |
| Loop Jacobian is ill-conditioned, for example near a singularity | Expect slower or failing solves | The numerical scheme needs G_y and G_q to be well conditioned [arxiv:2412.13638 §4.1.2]. At the input singularity of the example, inner iterations stayed at most two [arxiv:2412.13638 §6.4.3] |
| Loops contain redundant constraints | Not covered | The paper claims they can be handled but gives no rule for choosing independent rows [arxiv:2412.13638 §7, §3.3] |
| Limb platform DOF differs from limb DOF | Not covered | The inverse kinematics assumes non-redundant limbs, δ_p(l) = δ_l [arxiv:2412.13638 §3.6] |
| Feedforward torques are needed from task-space dynamics | Use the task-space model, with J_IK square and invertible | The control law inverts J_IK [arxiv:2412.13638 eq. 45] |
| Integrating only velocity-level constraints | Avoid for position-accurate models | The position error grows, so the paper uses the position-level Newton solution [arxiv:2412.13638 §4.1.2] |
| Loop is planar and simple, and a closed form exists | Solve by hand | The paper solves its proximal four-bar loop in closed form and reserves the numerical solver for the distal loop [arxiv:2412.13638 §6.2] |

## 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) [arxiv:2412.13638 alg. 1, alg. 2, alg. 3].

```pseudocode
# 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
```

```pseudocode
# 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 [arxiv: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
  [arxiv: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
  [arxiv: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 [arxiv: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
[arxiv: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](/papers/2412.13638): solves each closed loop numerically inside its limb, with nested and compound inverse-kinematics schemes and a task-space dynamics model for feedforward control.