Motion primitives

Overview

A motion primitive is a reusable piece of motion that a planner or controller combines with others. The three cards so far use the term for different designs, and the designs do not share their mathematics.

• Graph edges for search. A finite set of constant controls, each applied for a fixed time, gives pieces that a planner chains into a route.
• Learned movement templates. A distribution over trajectories is fitted to demonstrations, then conditioned on the first part of a new motion.
• Parameterised skills for language planners. A small library of learned skills, each with a parameter that is optimised for every use, is sequenced by a language model and checked for feasibility 2303.12153 §3.1.

For the first design, each primitive applies one constant control input for a fixed duration τ, as in the planner of 1709.05401 §3.1. The end state follows from the system's closed-form solution, so no numerical integration is needed at search time.

Every control in a finite set, applied from every reachable state, gives a graph. Search then finds a route through it 1709.05401 §3.2 1709.05401 §3.3. The common invariant is that the primitives are the only moves the planner makes, so any route it returns is a chain of feasible pieces. The paper's claim that the planned trajectory is dynamically feasible rests on this construction, with each edge checked against the bounds 1709.05401 §3.5.

The learned design does not enumerate moves. It fits a Gaussian over the weights of a basis-function trajectory model, and it updates that Gaussian with the operator's observed motion 2411.01014 §2.1 2411.01014 §2.4. The paper does not state a feasibility argument for the conditioned trajectory. Its tracking controller is described only in structure, with no gains or limits 2411.01014 §2.8.

Three papers with a card cover this concept so far: Liu et al., 2017 for the lattice, Penco et al., 2024 for the learned design, and Lin et al., 2023 for the skill-based planner. They share the name, not the method, so compare variants only within one design.

Variants

Constant-input lattice with an LQMT heuristic

The control set is a lattice of M = (2μ+1)³ constant inputs, with spacing u_max / μ per axis 1709.05401 §3.1. Figure 6 shows 9 primitives in 2-D and 27 in 3-D, which implies μ = 1; the paper does not state μ in the text 1709.05401 fig. 6. Each primitive has the cost (‖u‖² + ρ)τ 1709.05401 §3.1.

Edges are kept only if the primitive's geometric path is collision-free and its derivatives stay within bounds. The checks use closed-form extrema, and positions are checked at sampled times on an occupancy grid 1709.05401 §3.5.

The A* heuristic is either a minimum-time bound or the optimal cost of the linear quadratic minimum-time (LQMT) problem with the constraints dropped 1709.05401 §3.4.1 1709.05401 §3.4.2. The paper reports that the LQMT heuristic expands fewer nodes on one query 1709.05401 fig. 5. Its closed forms are given for velocity and acceleration control only 1709.05401 §3.4.2.

The paper refines the lattice route afterwards with a QP that minimises the integral of the squared n-th derivative 1709.05401 §4. Refinement is a separate step, and the paper says the result may be unsafe or infeasible 1709.05401 §4.

Learned probabilistic primitives with conditioning and affordance blending

A probabilistic movement primitive (ProMP) writes a trajectory as a linear basis-function model with weights w, and the weights are Gaussian 2411.01014 §2.1 2411.01014 eq. 1. Each demonstration gets its own weight vector by ridge regression, and the mean and covariance of the weights are the sample statistics over the demonstrations 2411.01014 §2.2 2411.01014 eq. 2 2411.01014 eq. 3. The paper's demonstrations were recorded in simulation, fewer than 30 in general 2411.01014 §2. Each ProMP models one body part, and it is learned in the object's frame 2411.01014 §2.2.

Recognition picks the learned ProMP whose mean is closest to the first observed samples, using a sum of norms over a window that the paper sets to about a quarter or a third of the motion 2411.01014 §2.3 2411.01014 eq. 4. Conditioning then applies Bayes' rule to the weight distribution, using the observed target and its noise 2411.01014 §2.4 2411.01014 eq. 5 2411.01014 eq. 8. The paper says this is what adapts the motion to the operator's own way of doing the task 2411.01014 §2.4.

Where an affordance exists, the conditioned output is blended into the first sample of the affordance trajectory with a logistic weight that rises from 0 to 1 2411.01014 §2.7 2411.01014 eq. 9 2411.01014 eq. 10. The paper gives no values for the blending coefficients 2411.01014 §2.7. Object poses come from ArUco markers, which the authors describe as a temporary solution 2411.01014 §2.5.

Parameterised skills checked inside an LLM planner

Here a primitive is one parameterised action, not a timed trajectory piece. The skill library has four skills: Pick, Place, Pull and Push. Each has a policy, a parameterised primitive whose parameters are grasp or placement poses, or the start, direction and distance of a pull or push, and an ensemble of Q-functions and a dynamics model 2303.12153 §3.1 app. A.1.

A language model proposes skill sequences 2303.12153 §4.2 2303.12153 §4.3. Each candidate is then optimised for its parameters with geometric feasibility planning, which picks parameters that maximise the expected product of step reward probabilities over predicted states 2303.12153 §3.3 2303.12153 eq. 4. The candidate's feasibility is scored with the Q-value at its optimised parameter 2303.12153 eq. 12. A candidate is rejected when the variance of its Q-ensemble is at or above a per-skill threshold 2303.12153 §4.5 2303.12153 eq. 13.

The paper's planner alternates between two modes. Shooting asks for whole sequences in one query, and greedy search adds one skill per step 2303.12153 §4.4 2303.12153 alg. 3. A plan ends when a goal that the language model predicted holds in a predicted state 2303.12153 §4.1 2303.12153 eq. 6. The paper uses K = 5 candidates per query 2303.12153 app. A.3. The Lin et al. card has the paper's own pseudocode.

When to use which

The designs answer different questions, so the rows below are chosen by constraint. Where the table gives numbers, they come from the card cited.

The timing figures are author-reported. They use the paper's own hardware and code, which the paper does not fully specify 1709.05401 tab. 1. Re-planning in the paper ran at 3 Hz in simulation with a 3 m/s speed limit 1709.05401 §5.3.

The learned design's evidence is also small. Its feasibility study has eight participants, and no significance tests are reported 2411.01014 §4.2. Its punching evaluation used ten test trajectories and compared against no baseline 2411.01014 §4.1.

Implementation sketch

Language-agnostic outline of the lattice successor step, its heuristic hook, and the learned design's conditioning step. The paper pseudocode is in 1709.05401 alg. 1 and 2411.01014 §2.4; the sketch below is our own wording.

# Build the outgoing edges of one state from a finite set of controls
# Input:  state (position and derivatives), controls (M values), tau, rho
# Output: successor states and their edge costs

def successors(state, controls, tau, rho):
    result = []
    for u in controls:
        # Reject the primitive if its path leaves free space or breaks a bound
        # [arxiv:1709.05401 §3.5]
        if not primitive_is_valid(state, u, tau):
            continue
        # End state of the constant-input piece  [arxiv:1709.05401 §3.1]
        next_state = propagate(state, u, tau)
        # Cost of applying u for tau  [arxiv:1709.05401 §3.1]
        cost = (dot(u, u) + rho) * tau
        result.append((next_state, cost))
    return result

# Heuristic hook for A*: a lower bound on the cost-to-go
# Input:  state, goal, rho
# Output: admissible estimate

def heuristic(state, goal, rho):
    # Minimum-time bound from the position gap  [arxiv:1709.05401 §3.4.1]
    # A tighter LQMT bound from the same state is in [arxiv:1709.05401 §3.4.2]
    return rho * linf_distance(state.position, goal.position) / v_max

# Condition a learned ProMP on observed samples  [arxiv:2411.01014 §2.4]
# Input:  mu_w, sigma_w of the chosen ProMP; phi_obs (basis at observed times);
#         y_obs (observed targets); sigma_obs (observation noise)
# Output: posterior mean and covariance of the weights

def condition(mu_w, sigma_w, phi_obs, y_obs, sigma_obs):
    # Gain: how strongly each observation moves the weights  [arxiv:2411.01014 eq. 8]
    # Shapes follow the paper's notation, which is not consistent; see Contradictions
    gain = sigma_w @ phi_obs @ inverse(sigma_obs
                                       + phi_obs.T @ sigma_w @ phi_obs)
    # Shift the mean by the prediction error  [arxiv:2411.01014 eq. 6]
    mu_post = mu_w + gain @ (y_obs - phi_obs.T @ mu_w)
    # Shrink the covariance by the same gain  [arxiv:2411.01014 eq. 7]
    sigma_post = sigma_w - gain @ phi_obs.T @ sigma_w
    return mu_post, sigma_post

Contradictions

Between papers, none known: the three cards use the term for different objects. Within and between the paper and its code, these disagree:

• Task labels in the skill-based paper. The Figure 4 caption, the appendix table and the results text assign different property labels to tasks 3 to 6 2303.12153 fig. 4 2303.12153 app. B 2303.12153 §6.2. Check any per-task comparison against the figure.
• Partial-perception share in the skill-based paper. The text says over 90% of solutions to those tasks combine both planners 2303.12153 §6.3. The table gives 86% for task 4 2303.12153 tab. 1.
• Usefulness score in the skill-based paper. Equations 9 and 10 define a probability, the text describes a sum of token log-probabilities 2303.12153 §4.3, and the appendix describes a softmax log-probability damped by β = 0.3, without the damping formula 2303.12153 app. A.3.
• Algorithm return in the skill-based paper. The hybrid loop returns the shooting result without the greedy prefix, so the plan it returns is not joined to the steps before it 2303.12153 alg. 3.
• Heuristic in code. The paper presents the LQMT heuristic h2 as the tighter bound and uses it to speed up search 1709.05401 §5.1. The code's default ignores the dynamics, so the default heuristic is the minimum-time bound h1 env_base.h.
• Eq. 12 sign. The condition on the sample count is printed with ≥, while the text needs the spacing to be at most R 1709.05401 eq. 12 1709.05401 §3.5. The code uses the ≤ reading env_map.h. Read the printed condition with that in mind.
• Blending function. The text requires the blend weight to be 0 at the start and 1 at the end 2411.01014 §2.7, but the logistic form in eq. 10 has range (0, 1) for finite coefficients 2411.01014 eq. 10. The paper gives no coefficient values to resolve this.
• Transposes. The basis matrix appears with different transposes in eq. 1, eq. 4 and eq. 6 2411.01014 eq. 1 2411.01014 eq. 4 2411.01014 eq. 6. Check the shapes before implementing.

Papers

• Liu et al., 2017: plans quadrotor trajectories by A* over a lattice of constant-input primitives, with a closed-form LQMT heuristic.
• Penco et al., 2024: conditions learned ProMPs on the operator's first motion and blends them into affordance templates for humanoid teleoperation.
• Lin et al., 2023: an LLM proposes skill sequences over learned Pick, Place, Pull and Push skills, each checked by geometric feasibility planning and Q-ensemble rejection, with a hybrid of whole-plan and step-wise search.