Consider a physical serial manipulator with configuration space \( \mathcal{Q}_{\text{phys}} \) and a mathematical model with generalized coordinates \( \mathbf{q} \in \mathbb{R}^n \). The physical end-effector pose is a map

\[ F_{\text{phys}}:\mathcal{Q}_{\text{phys}}\to SE(3),\quad x \mapsto T_{\text{ee}}^{\text{phys}}(x), \]

while the modeled serial-chain kinematics uses

\[ F_{\text{mod}}:\mathbb{R}^n\to SE(3),\quad \mathbf{q} \mapsto T_{\text{ee}}(\mathbf{q}). \]

Implicitly, we assume there exists a mapping \( g:\mathcal{Q}_{\text{phys}} \to \mathbb{R}^n \) such that, on a region of interest \( \mathcal{R}\subset \mathcal{Q}_{\text{phys}} \),

\[ T_{\text{ee}}^{\text{phys}}(x) \approx T_{\text{ee}}(g(x)),\quad x\in\mathcal{R}. \]

The modeling assumptions determine the existence and quality of such an approximation. A convenient way to quantify kinematic modeling error on the modeled coordinates is

\[ e(\mathbf{q}) = \operatorname{log}\!\big(T_{\text{ee}}^{\text{phys}}(\mathbf{q})^{-1}T_{\text{ee}}(\mathbf{q})\big)^\vee \in \mathbb{R}^6, \]

where the matrix logarithm and the \(\vee\)-operator map small pose discrepancies into a twist representation in \( \mathbb{R}^6 \). A typical design objective is to ensure

\[ \sup_{\mathbf{q}\in\mathcal{Q}_\text{task}}\|e(\mathbf{q})\| \le \varepsilon, \]

for a task region \( \mathcal{Q}_\text{task} \subset \mathbb{R}^n \) and tolerance \( \varepsilon > 0 \).

flowchart TD
  P["Physical serial mechanism"] --> A1["Choose abstraction of links and joints"]
  A1 --> A2["Assume ideal properties (rigid, frictionless, no backlash)"]
  A2 --> A3["Define generalized coordinates q in R^n"]
  A3 --> A4["Define kinematic map F_mod: q → SE(3)"]
  A4 --> A5["Check error e(q) against tolerance"]
  A5 -->|too large| R["Refine model \n(add compliance, offsets, etc.)"]
  A5 -->|acceptable| USE["Use model for analysis \nand downstream dynamics"]
        

In the remainder of the lesson we make the main kinematic assumptions explicit, write their mathematical forms, and discuss what breaks when they are violated.

A link \( i \) is modeled as a rigid body with body frame \( \{i\} \). For any two material points attached to the link with body-frame coordinates \( p_a^i, p_b^i \in \mathbb{R}^3 \), rigidity means

\[ \|p_a^i(t) - p_b^i(t)\| = \|p_a^i(0) - p_b^i(0)\|,\quad \forall t. \]

In world coordinates, the pose of link \( i \) is \( T_i(t) \in SE(3) \), and the position of point \( p_a^i \) is

\[ p_a(t) = R_i(t)p_a^i + \mathbf{o}_i(t), \]

with \( R_i(t)\in SO(3) \) and \( \mathbf{o}_i(t)\in\mathbb{R}^3 \). Rigidity implies that the pose of the link is completely determined by the 6-DOF transform \( T_i(t) \), with no additional deformation variables.

In a serial chain with \( n \) joints, the ideal rigid-link forward kinematics can be written as a product of relative transforms:

\[ T_{\text{ee}}^{\text{rigid}}(\mathbf{q}) = T_0 \left(\prod_{i=1}^n T_i(q_i)\right) T_{\text{tool}}, \]

where \( T_0 \) is a fixed base transform, and \( T_{\text{tool}} \) is the fixed transform from the last link to the tool frame.

If we model link flexibility, we introduce additional generalized coordinates \( \boldsymbol{\eta} = (\eta_1,\dots,\eta_n) \) describing elastic deflections, leading to

\[ T_{\text{ee}}^{\text{flex}}(\mathbf{q},\boldsymbol{\eta}) = T_0 \left(\prod_{i=1}^n T_i(q_i,\eta_i)\right) T_{\text{tool}}. \]

The assumption of rigid links is precisely \( T_i(q_i,\eta_i) = T_i(q_i) \) with no extra state \( \eta_i \). This keeps the configuration space dimension equal to \( n \) but neglects load-dependent deformations. In high-precision or lightweight manipulators, this can introduce pose errors that depend on the applied forces and torques, which a purely kinematic model cannot capture.

Each serial joint is modeled as an ideal kinematic pair with a scalar coordinate \( q_i \). The allowable relative transforms of joint \( i \) form a one-dimensional subset \( \mathcal{S}_i \subset SE(3) \) (e.g., rotations about a fixed axis for a revolute joint). The joint map is

\[ \psi_i:\mathbb{R} \to SE(3),\quad q_i \mapsto T_i(q_i)\in\mathcal{S}_i. \]

The ideal-joint assumptions include:

• No backlash or clearance: each value of \( q_i \) corresponds to a unique relative pose.
• No joint elasticity: the relative pose depends only on \( q_i \), not on loads.
• No hidden constraints between joints: the coordinates \( q_1,\dots,q_n \) are independent.

In a more general parametric description, we may introduce joint coordinates \( \mathbf{x} \in \mathbb{R}^n \) subject to smooth constraints \( \boldsymbol{\phi}(\mathbf{x}) = \mathbf{0} \), with

\[ \mathcal{C} = \{\mathbf{x}\in\mathbb{R}^n \mid \boldsymbol{\phi}(\mathbf{x})=\mathbf{0}\}. \]

The dimension of the configuration manifold is then

\[ \dim \mathcal{C} = n - \operatorname{rank}\left( \frac{\partial \boldsymbol{\phi}}{\partial \mathbf{x}}(\mathbf{x}) \right). \]

The standard serial-chain model assumes \( \boldsymbol{\phi}\equiv\mathbf{0} \), so \( \dim \mathcal{C} = n \). Coupled joints such as counter-rotating pulleys violate this assumption.

Example (coupled joints). Consider three revolute joints with coordinates \( x_1,x_2,x_3 \) and a mechanical constraint \( x_3 = x_1 + x_2 \). Then

\[ \phi(\mathbf{x}) = x_3 - x_1 - x_2, \quad \frac{\partial \phi}{\partial \mathbf{x}} = \begin{bmatrix} -1 & -1 & 1 \end{bmatrix}, \]

with rank 1. Thus, \( \dim \mathcal{C} = 3-1 = 2 \), even though the naive serial-chain model with three independent coordinates would claim a 3-DOF system. Using the ideal independent-joint model here overestimates reachability and can produce inconsistent kinematic equations.

Backlash and dead zones are another violation: if there is a range \( |q_i| \le \delta \) where the physical link does not move, the physical joint map is not one-to-one. The ideal model still uses a smooth map \( \psi_i \), which is simpler to differentiate and invert but can mislead fine motion planning near direction reversals.

In a serial-chain model we choose:

• a base frame \( \{0\} \), often fixed to the robot base,
• a sequence of link frames \( \{1\},\dots,\{n\} \), and
• a tool frame \( \{\text{ee}\} \) attached to the end-effector.

The choice of frame placement and the definition of the zero configuration \( \mathbf{q}=\mathbf{0} \) are modeling decisions. Typically we impose a convenient reference configuration such that

\[ T_{\text{ee}}(\mathbf{0}) = T_0 T_{\text{chain}}(\mathbf{0}) T_{\text{tool}} = T_{\text{ref}}, \]

for some desired reference pose \( T_{\text{ref}} \in SE(3) \).

In reality, base and tool frames are only known up to calibration error. If the true base frame is related to the modeled base frame by an unknown transform \( \Delta T_0 \in SE(3) \) and there is a constant encoder offset \( \mathbf{q}_{\text{off}} \), the physical end-effector transform satisfies

\[ T_{\text{ee}}^{\text{phys}}(\mathbf{q}) = \Delta T_0 \, T_{\text{ee}}(\mathbf{q} + \mathbf{q}_{\text{off}}). \]

The common modeling assumption is \( \Delta T_0 = I \) and \( \mathbf{q}_{\text{off}} = \mathbf{0} \). When this is not the case, the model can be corrected via kinematic calibration. For small misalignment, write \( \Delta T_0 = \exp(\hat{\xi}_0) \) with \( \|\xi_0\| \ll 1 \), so that to first order

\[ T_{\text{ee}}^{\text{phys}}(\mathbf{q}) \approx T_{\text{ee}}(\mathbf{q} + \mathbf{q}_{\text{off}}) \exp(\hat{\xi}_0), \]

and the error twist \( \xi_0 \) can be estimated from calibration measurements. Ignoring such frame errors is acceptable only when their induced task-space error is below the required tolerance.

A final class of assumptions is local linearization of the kinematic map near a nominal configuration \( \mathbf{q}^* \). Let \( f:\mathbb{R}^n\to\mathbb{R}^m \) encode a vector of task coordinates (for instance, position components of the end-effector). A first-order Taylor expansion gives

\[ f(\mathbf{q}^+) \approx f(\mathbf{q}^*) + \left.\frac{\partial f}{\partial \mathbf{q}}\right|_{\mathbf{q}^*} (\mathbf{q}^+ - \mathbf{q}^*), \quad \mathbf{q}^+ = \mathbf{q}^* + \delta\mathbf{q}. \]

This linear approximation is widely used for analysis and control, but it is only valid when \( \|\delta\mathbf{q}\| \) is small.

Example (planar 1R link). For a single revolute joint with link length \( L \) in the plane, the end-effector position is

\[ f(q) = \begin{bmatrix} x(q) \\[4pt] y(q) \end{bmatrix} = \begin{bmatrix} L\cos q \\[4pt] L\sin q \end{bmatrix}. \]

Linearizing at \( q^* = 0 \) gives

\[ f(q) \approx f(0) + f'(0) \, q = \begin{bmatrix} L \\[4pt] 0 \end{bmatrix} + \begin{bmatrix} 0 \\[4pt] L \end{bmatrix} q = \begin{bmatrix} L \\[4pt] L q \end{bmatrix}. \]

Using standard Taylor remainder bounds,

\[ |\sin q - q| \le \frac{|q|^3}{6},\quad |\cos q - 1| \le \frac{q^2}{2}, \]

so the magnitude of the position error \( \|f(q)-f(0)-f'(0)q\| \) satisfies

\[ \|f(q) - f(0) - f'(0)q\| \le L\left(\frac{q^2}{2} + \frac{|q|^3}{6}\right). \]

Imposing a tolerance \( \|f(q)-f(0)-f'(0)q\| \le \varepsilon \) yields a corresponding admissible range \( |q| \le \delta \). Extending the linearized model beyond this neighborhood is a modeling assumption that can lead to significant trajectory-tracking errors.

flowchart TD
  N["Choose nominal configuration q*"] --> DQ["Specify admissible delta q range"]
  DQ --> LIN["Compute linearization f(q*) + A (q - q*)"]
  LIN --> ERR["Bound approximation error on delta q"]
  ERR -->|too large| REF["Shrink region or use nonlinear model"]
  ERR -->|acceptable| USE["Use linear model in control/analysis"]
        

We now implement a simple planar 2R manipulator model under several kinematic assumptions: (i) ideal rigid model, (ii) encoder offsets, and (iii) linearized small-angle model. The same conceptual assumptions appear in common robotics libraries (Python roboticstoolbox, C++ KDL/Pinocchio, MATLAB Robotics System Toolbox, etc.).

6.1 Python Implementation (NumPy)

import numpy as np
from enum import Enum
from dataclasses import dataclass

class Assumption(Enum):
    IDEAL = 0
    OFFSET = 1
    LINEARIZED = 2

@dataclass
class Planar2RModel:
    l1: float = 1.0
    l2: float = 1.0
    q_offset: np.ndarray = np.zeros(2)  # encoder offsets

    def fk(self, q, assumption=Assumption.IDEAL):
        """
        Simple 2R planar kinematics under different modeling assumptions.
        q: iterable of length 2, q = [q1, q2].
        Returns: np.array([x, y])
        """
        q = np.asarray(q, dtype=float).reshape(2,)
        if assumption == Assumption.OFFSET:
            q_eff = q + self.q_offset
        else:
            q_eff = q

        q1, q2 = q_eff

        if assumption == Assumption.LINEARIZED:
            # Linearize about q* = [0, 0]
            # Exact model: x = l1 cos(q1) + l2 cos(q1+q2)
            #             y = l1 sin(q1) + l2 sin(q1+q2)
            # First-order Taylor at q* gives:
            # x ≈ l1 + l2
            # y ≈ l1 q1 + l2 (q1 + q2)
            x = self.l1 + self.l2
            y = self.l1 * q1 + self.l2 * (q1 + q2)
        else:
            x = self.l1 * np.cos(q1) + self.l2 * np.cos(q1 + q2)
            y = self.l1 * np.sin(q1) + self.l2 * np.sin(q1 + q2)

        return np.array([x, y])


if __name__ == "__main__":
    model = Planar2RModel(l1=1.0, l2=1.0, q_offset=np.array([0.05, -0.02]))
    q = np.deg2rad([10.0, 20.0])

    p_ideal = model.fk(q, Assumption.IDEAL)
    p_offset = model.fk(q, Assumption.OFFSET)
    p_lin = model.fk(q, Assumption.LINEARIZED)

    print("Ideal:", p_ideal)
    print("With offsets:", p_offset)
    print("Linearized:", p_lin)
    print("Offset error norm:", np.linalg.norm(p_offset - p_ideal))
    print("Linearization error norm:", np.linalg.norm(p_lin - p_ideal))
      

Libraries such as roboticstoolbox represent serial chains via a SerialLink class whose internal forward kinematics matches the \( T_{\text{ee}}(\mathbf{q}) \) structure above. Encoder offsets, compliant joints, or base transforms are typically stored as additional parameters; using their default values corresponds to the ideal assumptions discussed earlier.

6.2 C++ Implementation (Basic Struct, Serial Chain)

#include <array>
#include <cmath>

enum class Assumption {
    Ideal,
    Offset,
    Linearized
};

struct Planar2RModel {
    double l1{1.0};
    double l2{1.0};
    std::array<double, 2> q_offset{{0.0, 0.0}};

    std::array<double, 2> fk(std::array<double, 2> q,
                               Assumption assumption) const {
        if (assumption == Assumption::Offset) {
            q[0] += q_offset[0];
            q[1] += q_offset[1];
        }

        double q1 = q[0];
        double q2 = q[1];

        double x, y;
        if (assumption == Assumption::Linearized) {
            // Same small-angle linearization as in Python
            x = l1 + l2;
            y = l1 * q1 + l2 * (q1 + q2);
        } else {
            x = l1 * std::cos(q1) + l2 * std::cos(q1 + q2);
            y = l1 * std::sin(q1) + l2 * std::sin(q1 + q2);
        }
        return {x, y};
    }
};

// In practice, C++ robotics libraries such as KDL or Pinocchio
// use the same ideal rigid-link, ideal-joint modeling assumptions,
// with additional optional parameters for more detailed effects.
      

6.3 Java Implementation (Object-Oriented Model)

public enum Assumption {
    IDEAL,
    OFFSET,
    LINEARIZED
}

public class Planar2RModel {
    private final double l1;
    private final double l2;
    private final double[] qOffset; // length 2

    public Planar2RModel(double l1, double l2, double[] qOffset) {
        this.l1 = l1;
        this.l2 = l2;
        this.qOffset = qOffset.clone();
    }

    public double[] fk(double[] q, Assumption assumption) {
        double q1 = q[0];
        double q2 = q[1];

        if (assumption == Assumption.OFFSET) {
            q1 += qOffset[0];
            q2 += qOffset[1];
        }

        double x, y;
        if (assumption == Assumption.LINEARIZED) {
            x = l1 + l2;
            y = l1 * q1 + l2 * (q1 + q2);
        } else {
            x = l1 * Math.cos(q1) + l2 * Math.cos(q1 + q2);
            y = l1 * Math.sin(q1) + l2 * Math.sin(q1 + q2);
        }
        return new double[]{x, y};
    }
}
      

6.4 MATLAB / Simulink Implementation

In MATLAB with the Robotics System Toolbox, a serial-chain manipulator is typically modeled as a rigidBodyTree object, which enforces the ideal rigid-link, ideal-joint assumptions by construction.

% MATLAB script: 2R planar arm with encoder offsets and linearized model
l1 = 1.0;
l2 = 1.0;
q_offset = [0.05; -0.02];

fk_ideal = @(q) [ ...
    l1*cos(q(1)) + l2*cos(q(1)+q(2)); ...
    l1*sin(q(1)) + l2*sin(q(1)+q(2)) ];

fk_offset = @(q) fk_ideal(q + q_offset);

fk_linear = @(q) [ ...
    l1 + l2; ...
    l1*q(1) + l2*(q(1)+q(2)) ];

q = deg2rad([10; 20]);
p_ideal  = fk_ideal(q);
p_offset = fk_offset(q);
p_lin    = fk_linear(q);

disp(p_ideal);
disp(p_offset);
disp(p_lin);

% Simulink note:
% A corresponding Simulink model can be built by:
% 1. Creating a "MATLAB Function" block implementing fk_ideal(q).
% 2. Adding blocks that inject constant offsets q_offset.
% 3. Using "Gain" blocks to form FK_LINEAR(q) and comparing outputs.
% This visually demonstrates the impact of different modeling assumptions.
      

6.5 Wolfram Mathematica Implementation (Symbolic)

(* 2R planar arm with symbolic kinematics and linearization *)

ClearAll["Global`*"];

l1 = 1.0;
l2 = 1.0;
q1 = Symbol["q1"];
q2 = Symbol["q2"];

x[q1_, q2_] := l1*Cos[q1] + l2*Cos[q1 + q2];
y[q1_, q2_] := l1*Sin[q1] + l2*Sin[q1 + q2];

(* Exact forward kinematics *)
fExact[q1_, q2_] := {x[q1, q2], y[q1, q2]};

(* First-order Taylor expansion around q1 = 0, q2 = 0 *)
fLinear[q1_, q2_] =
  Normal[
    Series[fExact[q1, q2], {q1, 0, 1}, {q2, 0, 1}]
  ];

(* Substitute numeric values for comparison *)
fExactNum  = fExact[10 Degree, 20 Degree];
fLinearNum = fLinear /. {q1 -> 10 Degree, q2 -> 20 Degree};

N[{fExactNum, fLinearNum}]
      

Symbolic expansion clarifies exactly which terms are neglected by the linearized model, and how the approximation error depends on the joint angles. This makes the underlying modeling assumptions fully explicit.

In this lesson we made explicit the main modeling assumptions underlying serial-chain kinematics:

• Rigid links justify representing each link by a single \( SE(3) \) transform without deformation variables.
• Ideal joints treat each relative motion as one-dimensional, independent, and free of backlash or elasticity, leading to a configuration space \( \mathbb{R}^n \) for an \( n \)-joint chain.
• Frame placement and zero configuration choices encode base, link, and tool frames, with calibration errors captured as extra fixed transforms and offsets.
• Local linearization approximates nonlinear kinematics near a nominal configuration and is justified only over a limited range of generalized coordinates.

We also showed how these assumptions appear in practical code across Python, C++, Java, MATLAB/Simulink, and Mathematica, and analyzed error bounds in simple examples. In subsequent chapters, these kinematic assumptions will feed directly into the derivation of forward-kinematics formulas and, later, into dynamic models of the same serial chains.