A robot taxonomy is a principled way to organize robots into families that share structural and behavioral properties. Taxonomy is not merely descriptive: it defines suitable mathematical models, sensing requirements, safety concerns, and control architectures. In formal terms, a taxonomy partitions a universe of robots \( \mathcal{R} \) into disjoint sets \( \mathcal{R} = \bigsqcup_{j=1}^m \mathcal{R}_j \) such that each class satisfies a defining predicate \( P_j(r) \).

We focus on four high-level predicates:

• \( P_M \): robots whose primary function is manipulating objects via articulated links (manipulators).
• \( P_B \): robots whose base moves through the environment (mobile robots).
• \( P_H \): robots with human-like morphology and task space (humanoids).
• \( P_S \): collectives whose capabilities emerge from multi-robot interaction (swarms).

flowchart LR
  R["Robots"] --> M["Manipulators"]
  R --> B["Mobile robots"]
  R --> H["Humanoids"]
  R --> S["Swarms"]

  M --> M1["Serial arms"]
  M --> M2["Parallel arms"]
  B --> B1["Wheeled"]
  B --> B2["Legged"]
  B --> B3["Tracked"]
  H --> H1["Upper-body humanoids"]
  H --> H2["Full-body humanoids"]
  S --> S1["Homogeneous swarms"]
  S --> S2["Heterogeneous swarms"]
        

Across all robot classes, a key mathematical descriptor is the configuration \( \mathbf{q} \), a minimal coordinate vector specifying the robot's pose and joint states. The set of all configurations is the configuration space, \( \mathcal{C} \subseteq \mathbb{R}^n \), where \( n \) is the robot’s degrees of freedom (DoF).

If a robot has \( n \) independent generalized coordinates, we write \( \mathbf{q} = (q_1,\ldots,q_n)^{\top} \). Later chapters will connect \( \mathbf{q} \) to frames and kinematics, but here we use it only for classification.

A structural DoF count for rigid-link mechanisms is given by the Grübler–Kutzbach criterion. Suppose a mechanism in 3D has \( N \) links including the base and \( J \) joints, where joint \( j \) removes \( c_j \) constraints. Then the mobility \( n \) is

\[ n = 6(N-1) - \sum_{j=1}^{J} c_j . \]

Proof sketch. A free rigid body in 3D has 6 DoF. With \( N-1 \) moving links (excluding ground), the unconstrained system has \( 6(N-1) \) DoF. Each joint introduces constraints that reduce freedom by \( c_j \). Assuming independent constraints gives the subtraction above. Dependence/loop-closure can reduce effective constraints; this is why some parallel mechanisms have non-intuitive mobility. ■

We will apply this lightly in each class below to highlight what “counts” as DoF for taxonomy, without doing full kinematic derivations.

A manipulator is a robot whose main capability is to position and orient an end-effector through articulated links and joints while the base is fixed or nearly fixed. The configuration is typically a joint vector \( \mathbf{q} \in \mathbb{R}^n \), with \( n \) equal to the number of actuated joints.

Morphological criterion. A robot is a manipulator if its task-relevant motion is dominated by internal joint motion, and the base contributes no or negligible DoF. Let base DoF be \( n_b \) and joint DoF be \( n_j \). Manipulators satisfy \( n_b \approx 0 \) and \( n \approx n_j \).

Serial arms. Serial manipulators are kinematic chains: \( \mathcal{C} = \mathcal{C}_1 \times \cdots \times \mathcal{C}_n \), where each joint space \( \mathcal{C}_i \) is usually an interval (revolute/prismatic). Their reachable set is high-dimensional but their stiffness is limited by accumulated compliance.

Parallel arms. Parallel manipulators have loop closure constraints: \( g(\mathbf{q}) = \mathbf{0} \), reducing \( \dim(\mathcal{C}) \). They are typically stiff and precise but with smaller workspaces.

Example DoF calculation. A 6R industrial arm has \( N=7 \) links and \( J=6 \) revolute joints. Each revolute joint removes 5 constraints (\( c_j=5 \)). Hence

\[ n = 6(7-1) - 6\cdot 5 = 36 - 30 = 6. \]

This matches intuition: a common manipulator standard is 6 DoF for full 3D pose control.

A mobile robot is one for which base motion is a primary capability. We write the configuration as \( \mathbf{q} = (\mathbf{q}_b,\mathbf{q}_j) \), where base coordinates \( \mathbf{q}_b \in \mathbb{R}^{n_b} \) include position/orientation on a surface or in 3D space.

Taxonomic criterion. Mobile robots satisfy \( n_b > 0 \) and base motion directly expands the task space. If the robot has a manipulator mounted on a moving base, it becomes a mobile manipulator with total DoF \( n = n_b + n_j \).

Typical families include:

• Wheeled robots: energy-efficient, common indoors.
• Tracked robots: high traction, rough terrain.
• Legged robots: discrete footholds, best for irregular terrain.

Even at a high level, motion constraints distinguish families. A planar free rigid base has 3 DoF (x, y, yaw), so \( \mathbf{q}_b = (x,y,\theta) \). If a mobility mechanism restricts motion, the feasible velocities lie in a subspace \( \mathcal{D}(\mathbf{q}_b) \subset T_{\mathbf{q}_b}\mathcal{C} \). In later lessons we will formalize these as holonomic vs. nonholonomic constraints.

A humanoid robot is not defined by intelligence, but by morphology resembling the human body: a torso, two legs for locomotion, and two arms for manipulation (often a head with sensors).

From a structural view, humanoids are hybrid systems combining a mobile base (legs) with multiple manipulators (arms). A minimal DoF decomposition is \( n = n_{\text{legs}} + n_{\text{arms}} + n_{\text{torso/head}} \). For example, if each leg has 6 actuated joints and each arm has 7, plus 2 torso joints, then

\[ n = 2\cdot 6 + 2\cdot 7 + 2 = 12 + 14 + 2 = 28. \]

Dynamic balancing requirement (high-level). Humanoid locomotion introduces underactuation phases, so feasible motion must satisfy balance conditions. Let \( \mathbf{r}_{\text{com}} \) be the center of mass (CoM) and \( \mathcal{P} \) the support polygon (convex hull of contact points). A sufficient static balance condition is \( \mathbf{r}_{\text{com}} \in \mathcal{P} \). This geometric predicate is central to humanoid taxonomy even before full dynamic models are introduced.

Thus, humanoids sit at the intersection of manipulation and mobility, but their classification highlights anthropomorphic task spaces (tools, stairs, door handles) and high DoF redundancy.

A robot swarm is a multi-robot system in which collective behavior emerges from local interactions rather than centralized control. If there are \( N \) agents, each with configuration \( \mathbf{q}_i \in \mathbb{R}^{n_a} \), then the swarm configuration is the product space

\[ \mathbf{Q} = (\mathbf{q}_1,\ldots,\mathbf{q}_N) \in \mathbb{R}^{N n_a}, \qquad \mathcal{C}_{\text{swarm}} = \mathcal{C}_a^N . \]

Swarm taxonomy is based on:

• Homogeneity: all agents share identical dynamics/models.
• Heterogeneity: agents have different roles or morphologies.
• Coordination topology: who can communicate/sense whom.

A standard mathematical abstraction uses a graph \( G=(V,E) \) with \( |V|=N \). Let adjacency matrix \( A=[a_{ij}] \), where \( a_{ij}=1 \) if agent \( j \) influences agent \( i \). The (out-degree) Laplacian is \( L=D-A \) with \( D=\mathrm{diag}(d_i) \), \( d_i=\sum_j a_{ij} \).

Consensus property (key swarm signature). Consider scalar states \( x_i(t) \) and the local rule

\[ \dot{x}_i = -\sum_{j=1}^N a_{ij}(x_i-x_j). \]

In vector form with \( \mathbf{x}=(x_1,\ldots,x_N)^\top \),

\[ \dot{\mathbf{x}} = -L\mathbf{x}. \]

Theorem. If the graph is connected (undirected) or has a spanning tree (directed), then all agents converge to a common value \( x_i(t)\to \bar{x} \) as \( t\to\infty \).

Proof (outline using linear systems ideas students know). For undirected connected graphs, \( L \) is symmetric positive semidefinite with eigenvalues \( 0=\lambda_1 < \lambda_2 \le \cdots \le \lambda_N \). Diagonalize \( L=U\Lambda U^\top \); then \( \mathbf{x}(t)=U e^{-\Lambda t}U^\top\mathbf{x}(0) \). Since \( e^{-\lambda_k t}\to0 \) for \( k\ge2 \), only the eigenvector for \( \lambda_1=0 \) remains, which is \( \mathbf{1} \). Therefore \( \mathbf{x}(t)\to (\mathbf{1}\mathbf{1}^\top/N)\mathbf{x}(0)=\bar{x}\mathbf{1} \). ■

This convergence-to-collective behavior is a defining mathematical hallmark of swarms.

Taxonomy often appears in software as a class hierarchy or metadata. Here are minimal, language-parallel examples that encode the four families. These are intentionally simple (no kinematics or perception yet).

7.1 Python (dataclasses + simple DoF utilities)

from dataclasses import dataclass
from typing import List, Optional

@dataclass
class Robot:
    name: str
    dof_base: int
    dof_joints: int
    n_agents: int = 1  # >1 indicates swarm
    humanoid: bool = False

    @property
    def dof_total(self) -> int:
        return self.dof_base + self.dof_joints

    def family(self) -> str:
        if self.n_agents > 1:
            return "Swarm"
        if self.humanoid:
            return "Humanoid"
        if self.dof_base > 0 and self.dof_joints == 0:
            return "Mobile robot"
        if self.dof_base == 0 and self.dof_joints > 0:
            return "Manipulator"
        if self.dof_base > 0 and self.dof_joints > 0:
            return "Mobile manipulator"
        return "Other"

robots = [
    Robot("6R arm", dof_base=0, dof_joints=6),
    Robot("Differential drive base", dof_base=3, dof_joints=0),
    Robot("Humanoid example", dof_base=6, dof_joints=22, humanoid=True),
    Robot("Micro-swarm", dof_base=3, dof_joints=0, n_agents=50)
]

for r in robots:
    print(r.name, "=>", r.family(), ", DoF total:", r.dof_total)
      

7.2 C++ (enum + struct)

#include <iostream>
#include <string>

enum class Family { Manipulator, Mobile, Humanoid, Swarm, MobileManipulator, Other };

struct Robot {
    std::string name;
    int dof_base;
    int dof_joints;
    int n_agents;
    bool humanoid;

    int dof_total() const { return dof_base + dof_joints; }

    Family family() const {
        if (n_agents > 1) return Family::Swarm;
        if (humanoid) return Family::Humanoid;
        if (dof_base > 0 && dof_joints == 0) return Family::Mobile;
        if (dof_base == 0 && dof_joints > 0) return Family::Manipulator;
        if (dof_base > 0 && dof_joints > 0) return Family::MobileManipulator;
        return Family::Other;
    }
};

int main() {
    Robot arm{"6R arm", 0, 6, 1, false};
    Robot base{"Wheeled base", 3, 0, 1, false};
    Robot hum{"Humanoid", 6, 22, 1, true};
    Robot swarm{"Swarm", 3, 0, 100, false};

    Robot robots[] = {arm, base, hum, swarm};
    for (const auto& r : robots) {
        std::cout << r.name << " DoF=" << r.dof_total() << std::endl;
    }
}
      

7.3 Java (inheritance)

abstract class Robot {
    String name;
    int dofBase, dofJoints, nAgents;
    boolean humanoid;

    Robot(String name, int dofBase, int dofJoints, int nAgents, boolean humanoid) {
        this.name = name; this.dofBase = dofBase; this.dofJoints = dofJoints;
        this.nAgents = nAgents; this.humanoid = humanoid;
    }

    int dofTotal() { return dofBase + dofJoints; }

    String family() {
        if (nAgents > 1) return "Swarm";
        if (humanoid) return "Humanoid";
        if (dofBase > 0 && dofJoints == 0) return "Mobile robot";
        if (dofBase == 0 && dofJoints > 0) return "Manipulator";
        if (dofBase > 0 && dofJoints > 0) return "Mobile manipulator";
        return "Other";
    }
}

public class TaxonomyDemo {
    public static void main(String[] args) {
        Robot arm = new Robot("6R arm", 0, 6, 1, false){};
        Robot mobile = new Robot("Wheeled base", 3, 0, 1, false){};
        Robot humanoid = new Robot("Humanoid", 6, 22, 1, true){};
        Robot swarm = new Robot("Swarm", 3, 0, 50, false){};

        Robot[] robots = {arm, mobile, humanoid, swarm};
        for (Robot r : robots) {
            System.out.println(r.name + " => " + r.family() + " (DoF " + r.dofTotal() + ")");
        }
    }
}
      

7.4 MATLAB (struct array + simple classifier)

robots(1) = struct('name','6R arm','dof_base',0,'dof_joints',6,'n_agents',1,'humanoid',false);
robots(2) = struct('name','Wheeled base','dof_base',3,'dof_joints',0,'n_agents',1,'humanoid',false);
robots(3) = struct('name','Humanoid','dof_base',6,'dof_joints',22,'n_agents',1,'humanoid',true);
robots(4) = struct('name','Swarm','dof_base',3,'dof_joints',0,'n_agents',50,'humanoid',false);

for k = 1:length(robots)
    r = robots(k);
    if r.n_agents > 1
        fam = 'Swarm';
    elseif r.humanoid
        fam = 'Humanoid';
    elseif r.dof_base > 0 && r.dof_joints == 0
        fam = 'Mobile robot';
    elseif r.dof_base == 0 && r.dof_joints > 0
        fam = 'Manipulator';
    elseif r.dof_base > 0 && r.dof_joints > 0
        fam = 'Mobile manipulator';
    else
        fam = 'Other';
    end
    fprintf('%s => %s (DoF %d)\\n', r.name, fam, r.dof_base + r.dof_joints);
end
      

These snippets encode the same taxonomy rule: \( n_b=0 \Rightarrow \) manipulator, \( n_b>0 \Rightarrow \) mobile, humanoid flag for anthropomorphic morphology, and \( N>1 \Rightarrow \) swarm.

Problem 1 (DoF Counting): A planar 3R serial arm has 3 moving links plus a fixed base. Each revolute joint in the plane removes 2 constraints. Use the planar Grübler–Kutzbach formula \( n = 3(N-1) - \sum c_j \) to compute its DoF.

Solution: In the plane, a free rigid body has 3 DoF. Here \( N=4 \) links (including ground) and \( J=3 \) joints with \( c_j=2 \) each:

\[ n = 3(4-1) - 3\cdot 2 = 9 - 6 = 3. \]

Thus the arm has 3 DoF, matching the number of actuated joints. ■

Problem 2 (Family Identification): A robot has a wheeled base modeled by \( (x,y,\theta) \) and a 5-DoF arm. Determine its family and total DoF.

Solution: Base DoF \( n_b=3 \), joint DoF \( n_j=5 \). Since both are nonzero, it is a mobile manipulator. Total DoF:

\[ n = n_b + n_j = 3 + 5 = 8. \]

■

Problem 3 (Humanoid DoF Decomposition): A humanoid has 6 DoF per leg, 7 DoF per arm, 2 DoF torso, 2 DoF neck. Compute total DoF and interpret redundancy.

Solution:

\[ n = 2\cdot 6 + 2\cdot 7 + 2 + 2 = 12 + 14 + 4 = 30. \]

With \( n=30 \), the humanoid is highly redundant: many more DoF than needed for simple tasks, enabling balance and obstacle avoidance. ■

Problem 4 (Consensus Rate): For an undirected connected swarm graph with Laplacian eigenvalues \( 0=\lambda_1 < \lambda_2 \le \cdots \), show that the slowest exponential convergence mode in \( \dot{\mathbf{x}}=-L\mathbf{x} \) decays at rate \( \lambda_2 \).

Solution: Diagonalize \( L=U\Lambda U^\top \). Then \( \mathbf{x}(t)=U e^{-\Lambda t}U^\top\mathbf{x}(0) \). Modes decay as \( e^{-\lambda_k t} \). The smallest positive eigenvalue \( \lambda_2 \) yields the slowest decaying non-consensus mode, hence it sets the asymptotic convergence rate. ■

Problem 5 (Taxonomy Predicate Design): Propose a predicate \( P(r) \) that separates manipulators from mobile robots using only DoF decomposition \( (n_b,n_j) \). Prove that your predicate partitions the set of single robots (ignore swarms).

Solution: Define \( P_M(r): n_b=0 \wedge n_j>0 \) and \( P_B(r): n_b>0 \wedge n_j=0 \). For any single robot with either base- or joint-dominant actuation, exactly one of these holds. They are disjoint because \( n_b \) cannot be both 0 and >0. Their union covers all robots in this restricted universe, giving a valid partition. Robots with both components fall into a third class (mobile manipulators), which is outside the two-set partition by construction. ■

We introduced four foundational robot families and characterized them with configuration spaces and DoF structure. Manipulators are joint-dominant, mobile robots are base-dominant, humanoids combine both with anthropomorphic task spaces, and swarms are multi-robot systems whose collective behavior can be analyzed through graph Laplacians and consensus dynamics. This taxonomy will be refined in the next lessons as we add moving bases, flexible robots, and field-specific categories.