After requirements engineering (Lesson 1), the next step is to generate candidate robot concepts that could satisfy those requirements. Mathematically, let \( \mathcal{X} \) denote the set of feasible concepts, each described by a vector of design variables \( \mathbf{x} \in \mathcal{X} \subset \mathbb{R}^n \) (continuous dimensions such as link lengths, motor ratings) plus discrete choices (wheel vs. leg, LiDAR vs. camera, etc.).

Requirements from Lesson 1 can be represented as constraints on \( \mathbf{x} \) and as target values on performance functions:

\[ \begin{aligned} \mathcal{X} &= \left\{ \mathbf{x} \in \mathbb{R}^n \,\middle|\, g_j(\mathbf{x}) \le 0,\; j=1,\dots,q \right\},\\ J_k(\mathbf{x}) &:\ \text{objective functions (e.g. cost, mass, tracking error)},\ k=1,\dots,m. \end{aligned} \]

Concept generation populates a finite subset \( \{\mathbf{x}^{(1)},\dots,\mathbf{x}^{(N)}\} \subset \mathcal{X} \) using creativity techniques (brainstorming, morphological charts) but the selection among those candidates is governed by multi-criteria optimization.

flowchart TD
  R["Requirements (functional, performance, safety)"] --> G["Generate many candidate concepts"]
  G --> F1["Filter by feasibility (constraints, physical limits)"]
  F1 --> E["Evaluate metrics: cost, weight, accuracy, power, etc."]
  E --> T["Analyze trade-offs (multi-criteria)"]
  T --> S["Select promising concepts for detailed design"]
        

For early-stage robot design, it is useful to combine continuous and discrete choices into a unified notation. Let \( \mathbf{x} = [\mathbf{x}_c^\top,\mathbf{x}_d^\top]^\top \), where \( \mathbf{x}_c \in \mathbb{R}^{n_c} \) are continuous variables (e.g. link lengths, motor torque ratings) and \( \mathbf{x}_d \in \{0,1,\dots\}^{n_d} \) encode discrete choices (e.g. mobility type, sensor type).

We can enforce basic physical limits and compatibility constraints as inequalities:

\[ \begin{aligned} g_1(\mathbf{x}) &= m(\mathbf{x}) - m_{\max} \le 0 &&\text{(mass limit)},\\ g_2(\mathbf{x}) &= P(\mathbf{x}) - P_{\max} \le 0 &&\text{(power limit)},\\ g_3(\mathbf{x}) &= v_{\min} - v(\mathbf{x}) \le 0 &&\text{(min speed)},\\ g_4(\mathbf{x}) &= \sigma_{\text{joint}}(\mathbf{x}) - \sigma_{\text{allow}} \le 0 &&\text{(stress)}. \end{aligned} \]

Here \( m(\mathbf{x}) \) is the total mass, \( P(\mathbf{x}) \) the peak electrical power, \( v(\mathbf{x}) \) a reachable speed, and \( \sigma_{\text{joint}}(\mathbf{x}) \) a worst-case joint stress (estimated using basic statics and linear control results for torque bounds).

The goal of concept generation is therefore to find many feasible \( \mathbf{x}^{(i)} \) satisfying \( g_j(\mathbf{x}^{(i)}) \le 0 \) for all \( j \), while exploring qualitatively different structures (e.g. wheeled vs. legged).

Real robot design is intrinsically multi-criteria: we want low cost, low mass, low energy consumption, and high performance. Let \( J_k(\mathbf{x}) \) be objectives to be minimized:

\[ \mathbf{J}(\mathbf{x}) = \begin{bmatrix} J_1(\mathbf{x}) \\ \vdots \\ J_m(\mathbf{x}) \end{bmatrix} = \begin{bmatrix} \text{cost}(\mathbf{x}) \\ \text{mass}(\mathbf{x}) \\ \text{energy}(\mathbf{x}) \\ \text{tracking_error}(\mathbf{x}) \\ \vdots \end{bmatrix} \]

To combine heterogeneous quantities, we first normalize them. Suppose among the generated concepts we observe ranges \( J_k^{\min}, J_k^{\max} \). A simple linear normalization (where 1 is best, 0 is worst) is:

\[ z_k(\mathbf{x}) = \frac{J_k^{\max} - J_k(\mathbf{x})}{J_k^{\max} - J_k^{\min}}, \quad k = 1,\dots,m. \]

For criteria to maximize (e.g. payload capacity), you can invert the sign or swap numerator and denominator.

A common aggregation is a weighted sum:

\[ U(\mathbf{x};\mathbf{w}) = \sum_{k=1}^m w_k\, z_k(\mathbf{x}) = \mathbf{w}^\top \mathbf{z}(\mathbf{x}), \quad \mathbf{w} \in \mathbb{R}^m,\ w_k \ge 0,\ \sum_{k=1}^m w_k = 1. \]

Here \( U(\mathbf{x};\mathbf{w}) \) is a scalar utility; higher \( U \) indicates a better concept given a specific weighting of trade-offs. Changing \( \mathbf{w} \) corresponds to changing the design priorities.

Weighted sums hide the structure of trade-offs. A more fundamental concept is Pareto optimality.

Definition (Dominance).

For two concepts \( \mathbf{x},\mathbf{y} \in \mathcal{X} \), we say that \( \mathbf{x} \) dominates \( \mathbf{y} \), written \( \mathbf{x} \prec \mathbf{y} \), if

\[ J_k(\mathbf{x}) \le J_k(\mathbf{y})\ \forall k \quad\text{and}\quad \exists \ell:\ J_\ell(\mathbf{x}) < J_\ell(\mathbf{y}). \]

Definition (Pareto optimality).

A concept \( \mathbf{x}^\star \in \mathcal{X} \) is Pareto optimal if there is no other \( \mathbf{x} \in \mathcal{X} \) such that \( \mathbf{x} \prec \mathbf{x}^\star \).

The set of all Pareto-optimal concepts is the Pareto front:

\[ \mathcal{P} = \left\{ \mathbf{x}^\star \in \mathcal{X} \,\middle|\, \nexists\,\mathbf{x} \in \mathcal{X}: \mathbf{J}(\mathbf{x}) \le \mathbf{J}(\mathbf{x}^\star), \ \mathbf{J}(\mathbf{x}) \ne \mathbf{J}(\mathbf{x}^\star) \right\}. \]

Each point on \( \mathcal{P} \) corresponds to a different trade-off between objectives. A concept off the Pareto front is unambiguously worse than some other concept.

Theorem (Weighted sums and Pareto optimality, convex case).

Assume \( \mathcal{X} \subset \mathbb{R}^n \) is convex, each \( J_k(\mathbf{x}) \) is convex, and \( \mathbf{w} \gt \mathbf{0} \). Then any solution of

\[ \min_{\mathbf{x} \in \mathcal{X}} \sum_{k=1}^m w_k J_k(\mathbf{x}) \]

is Pareto optimal. (But not all Pareto points are necessarily recovered for non-convex problems.)

Sketch of proof.

Suppose \( \mathbf{x}^\star \) solves the weighted sum but is not Pareto optimal. Then there exists \( \tilde{\mathbf{x}} \in \mathcal{X} \) such that \( J_k(\tilde{\mathbf{x}}) \le J_k(\mathbf{x}^\star) \) for all \( k \) and strictly smaller for at least one index. With strictly positive weights, \( \sum_k w_k J_k(\tilde{\mathbf{x}}) \lt \sum_k w_k J_k(\mathbf{x}^\star) \), contradicting optimality of \( \mathbf{x}^\star \). Convexity ensures that a global minimizer of the weighted sum exists and can be found using convex optimization techniques.

Using the scalar utility \( U(\mathbf{x};\mathbf{w}) \), the best concept under a given weighting is

\[ \mathbf{x}^\star(\mathbf{w}) \in \arg\max_{\mathbf{x} \in \mathcal{X}_{\text{cand}}} U(\mathbf{x};\mathbf{w}), \]

where \( \mathcal{X}_{\text{cand}} \) is the finite set of generated concepts. Since this is finite, the maximizer is always attained by at least one concept.

For two concepts \( \mathbf{x}^{(a)} \) and \( \mathbf{x}^{(b)} \), we can study sensitivity of the preference with respect to the weight vector \( \mathbf{w} \):

\[ U(\mathbf{x}^{(a)};\mathbf{w}) \ge U(\mathbf{x}^{(b)};\mathbf{w}) \iff \mathbf{w}^\top \left( \mathbf{z}(\mathbf{x}^{(a)}) - \mathbf{z}(\mathbf{x}^{(b)}) \right) \ge 0. \]

The inequality describes a half-space in weight space \( \mathbb{R}^m \). Thus, the region of weights for which a concept is preferred can be characterized geometrically and visualized in low dimensions (\( m=2,3 \)) to aid trade-off discussion with stakeholders.

A simple algorithm for trade-off studies over a finite set of concepts:

1. Generate a list of candidate concepts.
2. Compute constraint functions \( g_j(\mathbf{x}^{(i)}) \).
3. Discard infeasible concepts.
4. Compute objective values \( J_k(\mathbf{x}^{(i)}) \).
5. Normalize to obtain \( \mathbf{z}(\mathbf{x}^{(i)}) \).
6. Compute scalar utilities \( U(\mathbf{x}^{(i)};\mathbf{w}) \).
7. Compute Pareto front by dominance filtering.

flowchart TD
  A["Candidate concepts x(1)...x(N)"] --> B["Check constraints g_j(x)<=0"]
  B -->|feasible| C["Compute objectives J_k(x)"]
  B -->|infeasible| D["Discard concept"]
  C --> E["Normalize metrics z_k(x)"]
  E --> F["Compute utility U(x; w)"]
  C --> G["Dominance check between concepts"]
  G --> H["Identify Pareto set P"]
  F --> I["Rank concepts by U"]
  H --> J["Visualize trade-offs and choose finalists"]
        

Below is a Python prototype that: (i) stores candidate robot concepts, (ii) checks feasibility, (iii) computes normalized metrics, and (iv) finds both the best concept for a given weight vector and the Pareto front (discrete dominance).

import numpy as np

# Each concept: cost [k€], mass [kg], energy [Wh per mission], tracking_error [deg rms]
concepts = [
    {"name": "A_wheeled", "cost": 15.0, "mass": 40.0, "energy": 800.0, "tracking_error": 1.5},
    {"name": "B_tracked", "cost": 18.0, "mass": 50.0, "energy": 700.0, "tracking_error": 1.2},
    {"name": "C_legged",  "cost": 25.0, "mass": 55.0, "energy": 950.0, "tracking_error": 0.8},
]

# Constraints
MAX_MASS = 55.0    # kg
MAX_ENERGY = 1000  # Wh

def is_feasible(c):
    return (c["mass"] <= MAX_MASS) and (c["energy"] <= MAX_ENERGY)

feasible = [c for c in concepts if is_feasible(c)]

# Build arrays of objectives to minimize
costs   = np.array([c["cost"] for c in feasible])
masses  = np.array([c["mass"] for c in feasible])
energies = np.array([c["energy"] for c in feasible])
errors  = np.array([c["tracking_error"] for c in feasible])

def normalize_min_to_max(arr):
    # returns z where 1 is best (minimum) and 0 is worst (maximum)
    amin, amax = arr.min(), arr.max()
    if np.isclose(amax, amin):
        return np.ones_like(arr)
    return (amax - arr) / (amax - amin)

Z = np.vstack([
    normalize_min_to_max(costs),
    normalize_min_to_max(masses),
    normalize_min_to_max(energies),
    normalize_min_to_max(errors),
]).T  # shape: (N_feasible, m)

names = [c["name"] for c in feasible]

# Choose weights (cost, mass, energy, tracking_error)
w = np.array([0.3, 0.2, 0.2, 0.3])

utilities = Z @ w
best_idx = int(np.argmax(utilities))

print("Utilities:")
for i, name in enumerate(names):
    print(f"{name}: U = {utilities[i]:.3f}")

print("\nBest concept under current weights:", names[best_idx])

# Pareto front (discrete dominance for 4 objectives to minimize)
F = np.vstack([costs, masses, energies, errors]).T

def dominates(i, j):
    """Return True if concept i dominates concept j (for minimization)."""
    return np.all(F[i] <= F[j]) and np.any(F[i] < F[j])

pareto_indices = []
for i in range(len(F)):
    dominated = False
    for j in range(len(F)):
        if i != j and dominates(j, i):
            dominated = True
            break
    if not dominated:
        pareto_indices.append(i)

print("\nPareto-optimal concepts:")
for idx in pareto_indices:
    print(names[idx], "with objectives", F[idx])
      

This simple discrete analysis is already sufficient for many early-stage robot trade-off studies, especially when concepts are qualitatively distinct (e.g., wheels vs. legs).

In C++, we can implement the same weighted-sum scoring for concept ranking (omitting dominance filtering for brevity).

#include <iostream>
#include <vector>
#include <string>
#include <limits>

struct Concept {
    std::string name;
    double cost;
    double mass;
    double energy;
    double tracking_error;
};

struct NormalizedConcept {
    std::string name;
    double z_cost;
    double z_mass;
    double z_energy;
    double z_error;
};

int main() {
    std::vector<Concept> concepts = {
        {"A_wheeled", 15.0, 40.0, 800.0, 1.5},
        {"B_tracked", 18.0, 50.0, 700.0, 1.2},
        {"C_legged",  25.0, 55.0, 950.0, 0.8}
    };

    const double MAX_MASS = 55.0;
    const double MAX_ENERGY = 1000.0;

    std::vector<Concept> feasible;
    for (auto &c : concepts) {
        if (c.mass <= MAX_MASS && c.energy <= MAX_ENERGY) {
            feasible.push_back(c);
        }
    }

    // Find min and max for each metric
    auto init_min = std::numeric_limits<double>::max();
    auto init_max = std::numeric_limits<double>::lowest();
    double cost_min = init_min, cost_max = init_max;
    double mass_min = init_min, mass_max = init_max;
    double energy_min = init_min, energy_max = init_max;
    double error_min = init_min, error_max = init_max;

    for (auto &c : feasible) {
        cost_min = std::min(cost_min, c.cost);
        cost_max = std::max(cost_max, c.cost);
        mass_min = std::min(mass_min, c.mass);
        mass_max = std::max(mass_max, c.mass);
        energy_min = std::min(energy_min, c.energy);
        energy_max = std::max(energy_max, c.energy);
        error_min = std::min(error_min, c.tracking_error);
        error_max = std::max(error_max, c.tracking_error);
    }

    auto norm = [](double x, double xmin, double xmax) {
        if (std::abs(xmax - xmin) < 1e-9) return 1.0;
        return (xmax - x) / (xmax - xmin);
    };

    std::vector<NormalizedConcept> Z;
    for (auto &c : feasible) {
        NormalizedConcept z{
            c.name,
            norm(c.cost,   cost_min,   cost_max),
            norm(c.mass,   mass_min,   mass_max),
            norm(c.energy, energy_min, energy_max),
            norm(c.tracking_error, error_min, error_max)
        };
        Z.push_back(z);
    }

    // weights: cost, mass, energy, tracking_error
    double w_cost = 0.3, w_mass = 0.2, w_energy = 0.2, w_error = 0.3;

    double best_U = -1e9;
    std::string best_name;

    for (auto &z : Z) {
        double U = w_cost * z.z_cost
                 + w_mass * z.z_mass
                 + w_energy * z.z_energy
                 + w_error * z.z_error;
        std::cout << z.name << " : U = " << U << std::endl;
        if (U > best_U) {
            best_U = U;
            best_name = z.name;
        }
    }

    std::cout << "Best concept: " << best_name
              << " with utility " << best_U << std::endl;

    return 0;
}
      

This C++ code can be integrated into a larger design tool that iterates over many robot configurations produced by CAD or parametric models.

A Java implementation emphasizes encapsulation of concept data and scoring logic.

import java.util.ArrayList;
import java.util.List;

class RobotConcept {
    String name;
    double cost;
    double mass;
    double energy;
    double trackingError;

    RobotConcept(String name, double cost, double mass, double energy, double trackingError) {
        this.name = name;
        this.cost = cost;
        this.mass = mass;
        this.energy = energy;
        this.trackingError = trackingError;
    }
}

public class ConceptTradeoff {
    private static double norm(double x, double xmin, double xmax) {
        if (Math.abs(xmax - xmin) < 1e-9) return 1.0;
        return (xmax - x) / (xmax - xmin);
    }

    public static void main(String[] args) {
        List<RobotConcept> concepts = new ArrayList<>();
        concepts.add(new RobotConcept("A_wheeled", 15.0, 40.0, 800.0, 1.5));
        concepts.add(new RobotConcept("B_tracked", 18.0, 50.0, 700.0, 1.2));
        concepts.add(new RobotConcept("C_legged", 25.0, 55.0, 950.0, 0.8));

        final double MAX_MASS = 55.0;
        final double MAX_ENERGY = 1000.0;

        List<RobotConcept> feasible = new ArrayList<>();
        for (RobotConcept c : concepts) {
            if (c.mass <= MAX_MASS && c.energy <= MAX_ENERGY) {
                feasible.add(c);
            }
        }

        double costMin = Double.POSITIVE_INFINITY, costMax = Double.NEGATIVE_INFINITY;
        double massMin = Double.POSITIVE_INFINITY, massMax = Double.NEGATIVE_INFINITY;
        double energyMin = Double.POSITIVE_INFINITY, energyMax = Double.NEGATIVE_INFINITY;
        double errorMin = Double.POSITIVE_INFINITY, errorMax = Double.NEGATIVE_INFINITY;

        for (RobotConcept c : feasible) {
            costMin = Math.min(costMin, c.cost);
            costMax = Math.max(costMax, c.cost);
            massMin = Math.min(massMin, c.mass);
            massMax = Math.max(massMax, c.mass);
            energyMin = Math.min(energyMin, c.energy);
            energyMax = Math.max(energyMax, c.energy);
            errorMin = Math.min(errorMin, c.trackingError);
            errorMax = Math.max(errorMax, c.trackingError);
        }

        double wCost = 0.3, wMass = 0.2, wEnergy = 0.2, wError = 0.3;

        double bestU = -1e9;
        String bestName = "";

        for (RobotConcept c : feasible) {
            double zCost = norm(c.cost, costMin, costMax);
            double zMass = norm(c.mass, massMin, massMax);
            double zEnergy = norm(c.energy, energyMin, energyMax);
            double zError = norm(c.trackingError, errorMin, errorMax);

            double U = wCost * zCost + wMass * zMass + wEnergy * zEnergy + wError * zError;
            System.out.printf("%s : U = %.3f%n", c.name, U);

            if (U > bestU) {
                bestU = U;
                bestName = c.name;
            }
        }

        System.out.println("Best concept: " + bestName + " with U = " + bestU);
    }
}
      

Such a Java component can be embedded into larger enterprise tools used by design engineers and project managers.

In MATLAB, we can write the same computations in matrix form. Simulink can then realize the computation using Gain and Sum blocks to implement the weighted sum \( U = \mathbf{w}^\top \mathbf{z} \).

% Candidate concepts: rows = concepts, columns = [cost, mass, energy, tracking_error]
F = [ 15.0  40.0  800.0  1.5;
      18.0  50.0  700.0  1.2;
      25.0  55.0  950.0  0.8 ];

names = { 'A\_wheeled'; 'B\_tracked'; 'C\_legged' };

MAX_MASS   = 55.0;
MAX_ENERGY = 1000.0;

% Feasibility mask
isFeasible = (F(:,2) <= MAX_MASS) & (F(:,3) <= MAX_ENERGY);
F = F(isFeasible, :);
names = names(isFeasible);

% Normalize each column for minimization (1 = best, 0 = worst)
Fmin = min(F, [], 1);
Fmax = max(F, [], 1);
Z = (Fmax - F) ./ (Fmax - Fmin);   % implicit row-wise broadcast

% weights: cost, mass, energy, tracking_error
w = [0.3; 0.2; 0.2; 0.3];

U = Z * w;    % utility values for each concept

[Ubest, idxBest] = max(U);
fprintf('Best concept: %s, U = %.3f\n', names{idxBest}, Ubest);

% --- Simulink mapping idea ---
% In Simulink:
% 1) Represent Z as a vector signal (e.g., from a Constant block).
% 2) Use a Gain block with parameter w' (1-by-4) to compute U = w' * Z.
% 3) Optionally sweep w in time to visualize sensitivity of concept ranking.
      

Because students already know linear control, the mapping \( U = \mathbf{w}^\top \mathbf{z} \) is analogous to a static linear output map \( y = Cx \) in state-space form, with \( \mathbf{z} \) as a pseudo-state capturing normalized performance.

In this lesson we formalized concept generation and trade-off studies as a multi-criteria optimization problem over a finite set of candidate robot designs. We defined design variables, constraints, multi-objective cost functions, normalization procedures, and scalar utilities. Pareto optimality provides a principled way to identify non-dominated concepts, while weighted sums allow designers to encode preferences and rank concepts algorithmically. Practical implementations in Python, C++, Java, and MATLAB/Simulink demonstrate how these ideas integrate into engineering workflows. These tools will be used throughout later design stages, including co-design and prototyping cycles.