In Lessons 1–4 we categorized robots by structure and environment: manipulators, mobile robots, humanoids, swarms, moving-base systems, rigid/flexible bodies, and field robots. These are essential but incomplete for engineering decisions.

Real deployments start from an application: e.g., high-throughput pick-and-place, precision assembly, inspection in hazardous environments, assistive manipulation, autonomous delivery, or cooperative exploration. Application-driven classification asks:

• What task primitives are required? (move, grasp, inspect, assist, cooperate)
• What environment and interaction constraints dominate? (space, obstacles, humans)
• What performance metrics define success? (accuracy, speed, safety, endurance)

flowchart TD
  A["Application / Mission"] --> B["Task primitives + environment constraints"]
  B --> C["Requirement vector r"]
  C --> D["Candidate robot classes"]
  D --> E["Capability vectors c for each class"]
  E --> F["Feasible set + trade-offs"]
  F --> G["Application-driven class choice"]
        

Let an application be summarized by a requirement vector \( \mathbf{r} \in \mathbb{R}^m \). Each component is a normalized requirement for a task or environment attribute. Example components:

• \( r_1 \): required positional accuracy
• \( r_2 \): required payload / force
• \( r_3 \): mobility complexity (flat floor to rough terrain)
• \( r_4 \): human-interaction safety level
• \( r_5 \): endurance / energy autonomy

Each robot class \( \mathcal{K} \) (e.g., industrial arm, mobile manipulator, UAV, AUV, humanoid, swarm) is characterized by a capability vector \( \mathbf{c}_{\mathcal{K}} \in \mathbb{R}^m \), where \( c_j \) quantifies the achievable capability along requirement dimension \( j \).

We say robot class \( \mathcal{K} \) is feasible for application \( \mathbf{r} \) if

\[ \mathbf{c}_{\mathcal{K}} \succeq \mathbf{r} \quad \Longleftrightarrow \quad c_{\mathcal{K},j} \ge r_j \ \text{for all}\ j=1,\dots,m. \]

The feasible set is \( \mathcal{F}(\mathbf{r}) = \{ \mathcal{K} : \mathbf{c}_{\mathcal{K}} \succeq \mathbf{r} \} \). If \( \mathcal{F}(\mathbf{r}) = \varnothing \), the requirements must be relaxed or a new robot concept is needed.

Application-driven classification frequently yields multiple feasible classes. To reason about “better” classes, define dominance:

Definition (Capability dominance). For two classes \( \mathcal{K}_1, \mathcal{K}_2 \), we say \( \mathcal{K}_1 \) dominates \( \mathcal{K}_2 \) if

\[ \mathbf{c}_{\mathcal{K}_1} \succeq \mathbf{c}_{\mathcal{K}_2} \ \text{and}\ \mathbf{c}_{\mathcal{K}_1} \ne \mathbf{c}_{\mathcal{K}_2}. \]

Proposition. The relation \( \succeq \) defines a partial order on capability vectors.

Proof.

• Reflexive: \( \mathbf{c} \succeq \mathbf{c} \) since \( c_j \ge c_j \) for all \( j \).
• Antisymmetric: If \( \mathbf{c}_1 \succeq \mathbf{c}_2 \) and \( \mathbf{c}_2 \succeq \mathbf{c}_1 \), then \( c_{1,j}=c_{2,j} \) for all \( j \), so \( \mathbf{c}_1=\mathbf{c}_2 \).
• Transitive: If \( \mathbf{c}_1 \succeq \mathbf{c}_2 \) and \( \mathbf{c}_2 \succeq \mathbf{c}_3 \), then \( c_{1,j}\ge c_{2,j}\ge c_{3,j} \) for all \( j \), hence \( \mathbf{c}_1 \succeq \mathbf{c}_3 \).

Therefore dominance induces a partially ordered set (poset) of robot classes. Classes not dominated by any other feasible class are Pareto-optimal for the application.

Formally, the Pareto set is

\[ \mathcal{P}(\mathbf{r}) = \left\{ \mathcal{K}\in \mathcal{F}(\mathbf{r}) : \nexists\,\mathcal{K}'\in \mathcal{F}(\mathbf{r}) \ \text{s.t.}\ \mathbf{c}_{\mathcal{K}'} \succ \mathbf{c}_{\mathcal{K}} \right\}. \]

Application-driven classification often narrows to \( \mathcal{P}(\mathbf{r}) \), after which cost, safety policy, or organizational constraints choose among Pareto options.

Feasibility and Pareto optimality are necessary but not sufficient. Real decisions include cost, risk, and maintainability. Define a utility function for application \( \mathbf{r} \):

\[ U(\mathcal{K}; \mathbf{r}) = \sum_{j=1}^m w_j \, u_j(c_{\mathcal{K},j}, r_j) \;-\; \lambda \, \text{Cost}(\mathcal{K}) \;-\; \rho \, \text{Risk}(\mathcal{K}, \mathbf{r}). \]

where weights \( w_j \ge 0 \), \( \sum_j w_j = 1 \), and \( u_j(\cdot) \) measures satisfaction of requirement \( j \). A common choice is a soft margin:

\[ u_j(c,r) = \begin{cases} 1 - e^{-\alpha_j(c-r)} & \text{if } c \ge r \\ -\beta_j(r-c) & \text{if } c < r \end{cases} \]

The optimal application-driven class is then \( \mathcal{K}^\star = \arg\max_{\mathcal{K}} U(\mathcal{K}; \mathbf{r}) \).

flowchart TD
  R["r: requirements"] --> F["F(r): feasible classes"]
  F --> P["P(r): Pareto set"]
  P --> U["maximize utility U(K;r)"]
  U --> Kstar["chosen class K*"]
        

Suppose the application is “autonomous shelf replenishment in a warehouse.” Choose \( m=4 \) normalized dimensions: accuracy, mobility, payload, and human-safety.

\[ \mathbf{r} = \begin{bmatrix} 0.7 \\ 0.8 \\ 0.5 \\ 0.9 \end{bmatrix} \quad \text{(high accuracy, high mobility, medium payload, very high safety).} \]

Candidate classes: industrial arm (IA), mobile base (MB), mobile manipulator (MM), humanoid (HU). Example capability matrix:

\[ C = \begin{bmatrix} 0.95 & 0.20 & 0.90 & 0.60 \\ 0.30 & 0.90 & 0.40 & 0.70 \\ 0.80 & 0.85 & 0.70 & 0.85 \\ 0.75 & 0.70 & 0.55 & 0.90 \end{bmatrix} \quad \text{rows: IA, MB, MM, HU.} \]

Feasibility check \( C_{\mathcal{K},j} \ge r_j \): IA fails mobility and safety, MB fails accuracy and payload, HU is feasible, MM is feasible. Dominance is not strict between MM and HU (trade-off), so \( \mathcal{P}(\mathbf{r})=\{\text{MM},\text{HU}\} \). Costs and deployment constraints may then select MM as the practical class.

We implement the formalism using numpy. (No ROS required here.)

import numpy as np

# Requirement vector r (accuracy, mobility, payload, safety)
r = np.array([0.7, 0.8, 0.5, 0.9])

classes = ["IndustrialArm", "MobileBase", "MobileManipulator", "Humanoid"]

# Capability matrix C (rows correspond to classes)
C = np.array([
    [0.95, 0.20, 0.90, 0.60],
    [0.30, 0.90, 0.40, 0.70],
    [0.80, 0.85, 0.70, 0.85],
    [0.75, 0.70, 0.55, 0.90]
])

# 1) Feasibility
feasible = [i for i in range(len(classes)) if np.all(C[i] >= r)]
print("Feasible classes:", [classes[i] for i in feasible])

# 2) Pareto-optimal among feasible
def dominates(ci, cj):
    return np.all(ci >= cj) and np.any(ci > cj)

pareto = []
for i in feasible:
    if not any(dominates(C[j], C[i]) for j in feasible if j != i):
        pareto.append(i)
print("Pareto set:", [classes[i] for i in pareto])

# 3) Utility
w = np.array([0.35, 0.25, 0.15, 0.25])  # weights sum to 1
alpha = np.array([4, 4, 3, 6])          # soft margin slopes
beta  = np.array([6, 5, 4, 8])          # penalty slopes
cost  = np.array([0.7, 0.4, 0.6, 0.9])  # normalized cost proxy

def satisfaction(c, r, alpha, beta):
    s = np.zeros_like(c)
    for j in range(len(c)):
        if c[j] >= r[j]:
            s[j] = 1 - np.exp(-alpha[j]*(c[j]-r[j]))
        else:
            s[j] = -beta[j]*(r[j]-c[j])
    return s

lam = 0.5  # cost importance
U = []
for i in range(len(classes)):
    s = satisfaction(C[i], r, alpha, beta)
    U.append(w @ s - lam*cost[i])

best = int(np.argmax(U))
print("Utility scores:", dict(zip(classes, U)))
print("Chosen class:", classes[best])
      

This compact code mirrors the mathematical definitions: feasibility, Pareto dominance, then utility maximization.

We use Eigen (standard linear algebra library often used in robotics).

#include <iostream>
#include <vector>
#include <string>
#include <Eigen/Dense>

bool dominates(const Eigen::VectorXd& ci, const Eigen::VectorXd& cj){
    bool ge_all = (ci.array() >= cj.array()).all();
    bool g_any  = (ci.array() >  cj.array()).any();
    return ge_all && g_any;
}

int main(){
    using Eigen::VectorXd;
    using Eigen::MatrixXd;

    std::vector<std::string> classes = {
        "IndustrialArm","MobileBase","MobileManipulator","Humanoid"
    };

    VectorXd r(4);
    r << 0.7, 0.8, 0.5, 0.9;

    MatrixXd C(4,4);
    C << 0.95,0.20,0.90,0.60,
         0.30,0.90,0.40,0.70,
         0.80,0.85,0.70,0.85,
         0.75,0.70,0.55,0.90;

    // Feasible set
    std::vector<int> feasible;
    for(int i=0;i<C.rows();++i){
        if( (C.row(i).array() >= r.transpose().array()).all() )
            feasible.push_back(i);
    }

    std::cout << "Feasible: ";
    for(int i: feasible) std::cout << classes[i] << " ";
    std::cout << std::endl;

    // Pareto set
    std::vector<int> pareto;
    for(int i: feasible){
        bool dom = false;
        for(int j: feasible){
            if(i==j) continue;
            if(dominates(C.row(j), C.row(i))) { dom = true; break; }
        }
        if(!dom) pareto.push_back(i);
    }

    std::cout << "Pareto: ";
    for(int i: pareto) std::cout << classes[i] << " ";
    std::cout << std::endl;
}
      

Java robotics projects often rely on EJML for matrix operations.

import org.ejml.simple.SimpleMatrix;
import java.util.*;

public class AppDrivenClassification {

    static boolean dominates(SimpleMatrix ci, SimpleMatrix cj){
        boolean geAll = true;
        boolean gAny = false;
        for(int j=0;j<ci.numCols();j++){
            double a = ci.get(0,j), b = cj.get(0,j);
            if(a < b) geAll = false;
            if(a > b) gAny = true;
        }
        return geAll && gAny;
    }

    public static void main(String[] args){
        String[] classes = {"IndustrialArm","MobileBase","MobileManipulator","Humanoid"};

        SimpleMatrix r = new SimpleMatrix(1,4,true, new double[]{0.7,0.8,0.5,0.9});

        SimpleMatrix C = new SimpleMatrix(4,4,true, new double[]{
            0.95,0.20,0.90,0.60,
            0.30,0.90,0.40,0.70,
            0.80,0.85,0.70,0.85,
            0.75,0.70,0.55,0.90
        });

        List<Integer> feasible = new ArrayList<>();
        for(int i=0;i<C.numRows();i++){
            SimpleMatrix ci = C.extractVector(true,i);
            boolean ok = true;
            for(int j=0;j<4;j++){
                if(ci.get(0,j) < r.get(0,j)) ok = false;
            }
            if(ok) feasible.add(i);
        }

        System.out.println("Feasible: " + feasible.stream().map(i->classes[i]).toList());

        List<Integer> pareto = new ArrayList<>();
        for(int i: feasible){
            boolean dom = false;
            for(int j: feasible){
                if(i==j) continue;
                if(dominates(C.extractVector(true,j), C.extractVector(true,i))){
                    dom = true; break;
                }
            }
            if(!dom) pareto.add(i);
        }

        System.out.println("Pareto: " + pareto.stream().map(i->classes[i]).toList());
    }
}
      

MATLAB is commonly used for early-stage robotic system studies. Here we compute feasibility, Pareto set, and utility.

% Requirement vector
r = [0.7; 0.8; 0.5; 0.9];

classes = {"IndustrialArm","MobileBase","MobileManipulator","Humanoid"};

% Capability matrix (rows are classes)
C = [0.95 0.20 0.90 0.60;
     0.30 0.90 0.40 0.70;
     0.80 0.85 0.70 0.85;
     0.75 0.70 0.55 0.90];

% Feasible indices
feasible = find(all(C >= r', 2));
disp("Feasible:"); disp(classes(feasible));

% Dominance check
dominates = @(ci,cj) all(ci >= cj) && any(ci > cj);

pareto = [];
for i = feasible'
    dom = false;
    for j = feasible'
        if i==j, continue; end
        if dominates(C(j,:), C(i,:)), dom = true; break; end
    end
    if ~dom, pareto = [pareto; i]; end
end
disp("Pareto:"); disp(classes(pareto));

% Utility parameters
w     = [0.35 0.25 0.15 0.25];
alpha = [4 4 3 6];
beta  = [6 5 4 8];
cost  = [0.7 0.4 0.6 0.9];
lambda = 0.5;

U = zeros(length(classes),1);
for i=1:length(classes)
    s = zeros(1,4);
    for j=1:4
        if C(i,j) >= r(j)
            s(j) = 1 - exp(-alpha(j)*(C(i,j)-r(j)));
        else
            s(j) = -beta(j)*(r(j)-C(i,j));
        end
    end
    U(i) = w*s' - lambda*cost(i);
end

disp("Utility scores:"); disp(table(classes', U));
[~,best] = max(U);
disp("Chosen class:"); disp(classes(best));
      

In Simulink, the same logic can be implemented with blocks performing vector comparison, min/max operations, and weighted summation for utility, enabling rapid what-if studies.

Problem 1 (Feasibility). Let \( \mathbf{r}\in\mathbb{R}^m \) be an application requirement vector and \( \mathbf{c}_{\mathcal{K}} \) capability vectors for classes \( \mathcal{K}_1,\dots,\mathcal{K}_n \). Prove that if \( \mathbf{c}_{\mathcal{K}_a} \succeq \mathbf{c}_{\mathcal{K}_b} \) and \( \mathcal{K}_b \in \mathcal{F}(\mathbf{r}) \), then \( \mathcal{K}_a \in \mathcal{F}(\mathbf{r}) \).

Solution.

Since \( \mathcal{K}_b \in \mathcal{F}(\mathbf{r}) \), we have \( \mathbf{c}_{\mathcal{K}_b} \succeq \mathbf{r} \), i.e., \( c_{b,j}\ge r_j \) for all \( j \). Given \( \mathbf{c}_{\mathcal{K}_a} \succeq \mathbf{c}_{\mathcal{K}_b} \), we have \( c_{a,j}\ge c_{b,j} \) for all \( j \). Therefore \( c_{a,j}\ge r_j \) for all \( j \), so \( \mathbf{c}_{\mathcal{K}_a} \succeq \mathbf{r} \), hence \( \mathcal{K}_a \in \mathcal{F}(\mathbf{r}) \).

Problem 2 (Pareto set). Consider three feasible classes with capability vectors \( \mathbf{c}_1=(0.9,0.5,0.7) \), \( \mathbf{c}_2=(0.8,0.8,0.6) \), \( \mathbf{c}_3=(0.7,0.6,0.9) \). Determine the Pareto set.

Solution.

Check dominance pairwise:

• \( \mathbf{c}_1 \) vs \( \mathbf{c}_2 \): \( 0.9>0.8 \), \( 0.5<0.8 \), so neither dominates.
• \( \mathbf{c}_1 \) vs \( \mathbf{c}_3 \): \( 0.9>0.7 \), \( 0.5<0.6 \), \( 0.7<0.9 \), so neither dominates.
• \( \mathbf{c}_2 \) vs \( \mathbf{c}_3 \): \( 0.8>0.7 \), \( 0.8>0.6 \), \( 0.6<0.9 \), so neither dominates.

Therefore none of the three feasible classes is dominated; hence \( \mathcal{P}=\{\mathcal{K}_1,\mathcal{K}_2,\mathcal{K}_3\} \).

Problem 3 (Utility choice). Suppose two Pareto-optimal classes have utilities \( U(\mathcal{K}_A;\mathbf{r}) = 0.52 \) and \( U(\mathcal{K}_B;\mathbf{r}) = 0.49 \), but the estimated risk term for \( \mathcal{K}_A \) has variance twice that of \( \mathcal{K}_B \). Give a principled decision rule using a risk-averse utility.

Solution.

Use a mean–variance adjusted objective:

\[ \tilde{U}(\mathcal{K};\mathbf{r}) = \mathbb{E}[U(\mathcal{K};\mathbf{r})] - \gamma \, \operatorname{Var}(\text{Risk}). \]

For some \( \gamma>0 \), a sufficiently risk-averse designer may select \( \mathcal{K}_B \) if the penalty \( \gamma \) times the higher variance makes \( \tilde{U}(\mathcal{K}_A) < \tilde{U}(\mathcal{K}_B) \). This is consistent with robust design under uncertainty.

Problem 4 (Designing requirement dimensions). For a “precision micro-assembly” application, propose a 5-dimensional requirement vector, and explain which robot class from Lessons 1–4 is most likely feasible.

Solution.

One reasonable vector is \( \mathbf{r}=(\text{accuracy},\text{payload},\text{mobility},\text{cleanliness},\text{cycle time}) \). Micro-assembly demands very high accuracy and cleanliness, moderate payload, low mobility, and high cycle time performance. This strongly favors a stationary rigid industrial manipulator with precision end-effector. Mobile or field robots are typically infeasible due to accuracy and stability limits.

We introduced application-driven classification as a requirement-to-capability mapping problem. Feasibility is expressed by componentwise inequalities, dominance yields a poset of robot classes, Pareto-optimal sets capture irreducible trade-offs, and a multi-criteria utility selects a final class for deployment. This viewpoint complements structural taxonomies from earlier lessons and prepares us to reason about robot design choices in later chapters.