A capstone project in advanced autonomy should be more than an implementation exercise. It should instantiate a well-defined problem class that can be expressed in terms of state, actions, an objective, and constraints, consistent with the control and planning formulations you have already seen. A convenient abstract representation is

\[ \mathcal{P} = \big(\mathcal{X}, \mathcal{U}, f, J, \mathcal{C}, \Theta \big), \]

where:

• \( \mathcal{X} \): state space (e.g., robot configuration space, task-augmented state).
• \( \mathcal{U} \): control or decision space (e.g., joint torques, high-level task actions).
• \( f \): state transition model (kinematics/dynamics, or abstract task transition model).
• \( J \): objective functional, e.g.

  \[ J(\pi) = \mathbb{E}\Big[ \sum_{t=0}^{T-1} \ell(x_t, u_t) + \Phi(x_T) \Big], \]

  for a policy \( \pi \), running cost \( \ell \), and terminal cost \( \Phi \).
• \( \mathcal{C} \): constraints (safety, collision avoidance, compute limits, etc.).
• \( \Theta \): tunable design or learning parameters (e.g. policy parameters, planner hyperparameters).

A concrete capstone topic (e.g. “risk-sensitive kinodynamic planning for multi-robot teams in clutter”) is then a particular instantiation of \( \mathcal{P} \) with specific choices for \( \mathcal{X}, \mathcal{U}, f, J, \mathcal{C}, \Theta \). Problem selection is the process of choosing such an instantiation that is:

• non-trivial but feasible within the semester,
• grounded in the existing literature,
• and potentially publishable or extensible beyond the course.

To reason about this deterministically, we will use scalar metrics and multi-criteria decision rules in the next section.

Let \( \mathcal{P}_{\text{cand}} = \{p_1,\dots,p_n\} \) be a finite set of candidate project ideas. For each candidate \( p \) we define quantitative attributes:

• \( I(p) \): expected scientific impact (e.g. depth of potential contribution).
• \( A(p) \): alignment with your interests and skills.
• \( D(p) \): difficulty level (technical depth, complexity).
• \( R(p) \): risk of failure (uncertainty in implementation and evaluation).

These are initially obtained by expert judgement, then refined via the literature map. To combine heterogeneous scales, we use min–max normalization. For any scalar attribute \( M:\mathcal{P}_{\text{cand}}\to\mathbb{R} \), define the normalized version:

\[ \tilde{M}(p) = \frac{M(p) - \min\limits_{q\in\mathcal{P}_{\text{cand}}} M(q)} {\max\limits_{q\in\mathcal{P}_{\text{cand}}} M(q) - \min\limits_{q\in\mathcal{P}_{\text{cand}}} M(q) + \varepsilon}, \]

where \( \varepsilon > 0 \) prevents division by zero when all candidates share the same value. Note that \( \tilde{M}(p) \in [0,1] \) for all \( p \).

A simple but effective scalarization is a weighted score:

\[ U(p;\boldsymbol{\lambda}) = \lambda_I \tilde{I}(p) + \lambda_A \tilde{A}(p) - \lambda_D \tilde{D}(p) - \lambda_R \tilde{R}(p), \]

with weights \( \boldsymbol{\lambda} = (\lambda_I,\lambda_A,\lambda_D,\lambda_R) \in \mathbb{R}_{\ge 0}^4 \) encoding your preferences. Since each normalized attribute lies in \( [0,1] \), we obtain deterministic bounds:

\[ -(\lambda_D + \lambda_R) \;\le\; U(p;\boldsymbol{\lambda}) \;\le\; \lambda_I + \lambda_A \quad \text{for all } p \in \mathcal{P}_{\text{cand}}. \]

The optimal candidate under a given weight vector is then \( p^{\star}(\boldsymbol{\lambda}) = \arg\max_{p\in\mathcal{P}_{\text{cand}}} U(p;\boldsymbol{\lambda}) \). Varying \( \boldsymbol{\lambda} \) traces out a Pareto frontier of projects that are not dominated by others in all metrics simultaneously.

Let \( \mathcal{L} = \{\ell_1,\dots,\ell_m\} \) denote the set of papers relevant to your topic family (e.g. sampling-based planners, TAMP, RL for manipulation). Two complementary representations are useful:

3.1 Citation graph

We model citations as a directed graph \( G = (V,E) \) with \( V = \{1,\dots,m\} \), where each vertex indexes a paper and

\[ A_{ij} = \begin{cases} 1, & \text{if paper } \ell_i \text{ cites } \ell_j,\\[4pt] 0, & \text{otherwise.} \end{cases} \]

The out-degree and in-degree of node \( i \) are

\[ d_{\text{out}}(i) = \sum_{j=1}^m A_{ij}, \qquad d_{\text{in}}(i) = \sum_{j=1}^m A_{ji}. \]

From \( A \) we can form a random-walk transition matrix

\[ P = D_{\text{out}}^{-1} A, \qquad D_{\text{out}} = \operatorname{diag}\big(d_{\text{out}}(1),\dots,d_{\text{out}}(m)\big), \]

and obtain a PageRank-style stationary distribution

\[ \boldsymbol{\pi}^{\star} = \alpha P^{\top} \boldsymbol{\pi}^{\star} + (1-\alpha)\frac{1}{m}\mathbf{1}, \quad \alpha \in (0,1), \]

which weights highly connected and frequently cited papers more strongly. This helps identify core theoretical works your capstone project should build upon.

3.2 Topic embeddings and similarity

A complementary view embeds papers in a continuous vector space. Let \( \varphi:\mathcal{L}\to\mathbb{R}^d \) be a feature or embedding map for papers (e.g. bag-of-words, TF–IDF, or pre-trained text embeddings). A simple similarity measure is the cosine similarity:

\[ s(\ell_i,\ell_j) = \frac{\varphi(\ell_i)^{\top}\varphi(\ell_j)} {\|\varphi(\ell_i)\|_2 \,\|\varphi(\ell_j)\|_2}, \]

which satisfies \( s(\ell_i,\ell_j) \in [-1,1] \). For a candidate project \( p \) with a textual description, one can embed it as \( \psi(p) \in \mathbb{R}^d \) (using the same pipeline as for papers) and quantify its distance to existing works:

\[ \operatorname{nov}(p) = \min_{\ell \in \mathcal{L}_{\text{core}}} \big\| \psi(p) - \varphi(\ell) \big\|_2, \]

where \( \mathcal{L}_{\text{core}} \subseteq \mathcal{L} \) is a subset of seminal or high-impact papers (e.g. those with large \( \pi^{\star}_i \)). Larger \( \operatorname{nov}(p) \) suggests greater novelty but may also indicate higher risk if no nearby works exist to provide methodological templates.

The following flowchart summarizes an end-to-end workflow from an initial thematic interest to a mathematically grounded choice of capstone problem with a structured literature map.

flowchart TD
  S["Start: high-level interest (e.g. planning, RL, TAMP)"] --> C1["Collect seed keywords and canonical papers"]
  C1 --> Q["Formulate structured search queries"]
  Q --> L["Build literature set L via databases (filter by theory focus)"]
  L --> G1["Construct citation graph and topic embeddings"]
  G1 --> A1["Analyze central papers, clusters, gaps"]
  A1 --> P1["Propose candidate projects P_cand"]
  P1 --> M1["Score each project using multi-criteria utility U(p; lambda)"]
  M1 --> CH["Choose project and refine problem specification"]
        

Later lessons will use the chosen problem specification as the basis for system architecture, implementation, and experimental design.

Beyond ranking candidate projects, we want to verify that our selected project addresses a gap in the literature. Consider the citation graph \( G = (V,E) \) and choose a radius \( r \in \mathbb{N} \). For a subset of papers \( S \subseteq V \) (e.g. the key works your project builds upon), define the r-neighborhood:

\[ \mathcal{N}_r(S) = \big\{ j \in V \;\big|\; \exists i\in S \text{ with graph distance } d_G(i,j) \le r \big\}. \]

The coverage fraction is then

\[ \operatorname{cov}_r(S) = \frac{|\mathcal{N}_r(S)|}{|V|} \in [0,1]. \]

Intuitively, \( \operatorname{cov}_r(S) \) measures how much of the literature graph is within at most \( r \) citation steps of the works you are explicitly using. A small coverage may indicate that you are missing important related papers, while a coverage extremely close to 1 with only a few works in \( S \) may indicate that your project is too close to existing highly central contributions.

A useful property is that coverage is monotone in \( S \): if \( S \subseteq T \), then \( \mathcal{N}_r(S) \subseteq \mathcal{N}_r(T) \), hence \( \operatorname{cov}_r(S) \le \operatorname{cov}_r(T) \). The proof uses only basic set inclusion and the definition of graph distance.

Combining coverage with novelty, one simple gap score for a candidate project \( p \) is

\[ G(p) = \operatorname{nov}(p) \cdot \Big( 1 - \operatorname{cov}_r(S_p) \Big), \]

where \( S_p \) is the set of core papers closest (in embedding space) to the project description. Large \( G(p) \) suggests that the project is simultaneously novel and situated in a region of the literature graph that is not already densely covered by a small collection of central works.

The next diagram illustrates how central theoretical papers, clusters, and potential gaps can be conceptualized within the citation graph and embedding space.

flowchart TD
  C1["Cluster A: sampling based planning theory"] --- C2["Cluster B: trajectory optimization theory"]
  C2 --- C3["Cluster C: RL for continuous control"]
  H1["Highly cited hub paper"]:::hub --> C1
  H1:::hub --> C2
  GAP["Sparse region connecting planning and RL"]:::gap
  C1 -. few citations .- GAP
  C3 -. few citations .- GAP
  P["Proposed capstone project"]:::proj --> GAP

  classDef hub stroke-width:3px;
  classDef gap stroke-dasharray: 5 5;
  classDef proj stroke-width:2px;
        

A promising capstone idea often sits in or near a “gap” region whose techniques can plausibly be drawn from multiple existing clusters (e.g. combining asymptotically optimal planning with model-based RL), but where little rigorous work has been done so far.

We now implement a small prototype in Python to:

1. Store candidate projects with heuristic metrics.
2. Compute the scalar utility \( U(p;\boldsymbol{\lambda}) \) and select the best.
3. Build a tiny citation graph using networkx, compute PageRank centrality, and estimate coverage.

import numpy as np
import networkx as nx

# -----------------------------
# 1. Candidate projects and metrics
# -----------------------------
projects = [
    {
        "name": "Kinodynamic RRT* with risk-sensitive cost",
        "I": 0.8,   # impact (0..1 heuristic)
        "A": 0.9,   # alignment
        "D": 0.7,   # difficulty
        "R": 0.6    # risk
    },
    {
        "name": "Task and motion planning for pick-place",
        "I": 0.7,
        "A": 0.8,
        "D": 0.5,
        "R": 0.4
    },
    {
        "name": "Multi-robot swarm coverage with formal specs",
        "I": 0.9,
        "A": 0.7,
        "D": 0.9,
        "R": 0.8
    }
]

def min_max_normalize(values, eps=1e-8):
    v = np.asarray(values, dtype=float)
    vmin, vmax = v.min(), v.max()
    return (v - vmin) / (vmax - vmin + eps)

# Extract raw metric vectors
I_raw = [p["I"] for p in projects]
A_raw = [p["A"] for p in projects]
D_raw = [p["D"] for p in projects]
R_raw = [p["R"] for p in projects]

# Normalize to [0,1]
I_norm = min_max_normalize(I_raw)
A_norm = min_max_normalize(A_raw)
D_norm = min_max_normalize(D_raw)
R_norm = min_max_normalize(R_raw)

for idx, p in enumerate(projects):
    p["I_norm"] = float(I_norm[idx])
    p["A_norm"] = float(A_norm[idx])
    p["D_norm"] = float(D_norm[idx])
    p["R_norm"] = float(R_norm[idx])

# Weight vector lambda
lam = {
    "I": 0.4,   # importance of impact
    "A": 0.3,   # importance of alignment
    "D": 0.2,   # penalty on difficulty
    "R": 0.1    # penalty on risk
}

def utility(p, lam):
    return (
        lam["I"] * p["I_norm"]
        + lam["A"] * p["A_norm"]
        - lam["D"] * p["D_norm"]
        - lam["R"] * p["R_norm"]
    )

best = None
best_score = -1e9
for p in projects:
    score = utility(p, lam)
    p["U"] = score
    if score > best_score:
        best_score = score
        best = p

print("Best project under lam =", lam, "is:")
print("\t", best["name"], "with score", best["U"])

# -----------------------------
# 2. Citation graph analysis
# -----------------------------
G = nx.DiGraph()

# Nodes: toy IDs mapped to canonical papers
G.add_nodes_from([
    (1, {"title": "RRT* optimal kinodynamic planning"}),
    (2, {"title": "PRM* and asymptotic optimality"}),
    (3, {"title": "Risk-sensitive motion planning"}),
    (4, {"title": "Formal methods for motion planning"}),
    (5, {"title": "RL for continuous robot control"})
])

# Add directed citation edges (i cites j)
edges = [
    (1, 2),
    (3, 1),
    (3, 2),
    (4, 1),
    (4, 3),
    (5, 3),
    (5, 2)
]
G.add_edges_from(edges)

# PageRank centrality
pagerank = nx.pagerank(G, alpha=0.9)
print("\nPageRank centrality:")
for node_id, score in sorted(pagerank.items()):
    print(node_id, G.nodes[node_id]["title"], ":", round(score, 3))

# r-neighborhood coverage: given a set of seed papers
def r_neighborhood(G, seeds, r):
    """Return set of nodes within graph distance <= r from seeds."""
    out = set()
    for s in seeds:
        out.add(s)
        # BFS up to depth r
        frontier = {s}
        for _ in range(r):
            new_frontier = set()
            for u in frontier:
                for v in G.successors(u):
                    if v not in out:
                        out.add(v)
                        new_frontier.add(v)
            frontier = new_frontier
    return out

def coverage(G, seeds, r):
    n = G.number_of_nodes()
    return len(r_neighborhood(G, seeds, r)) / float(n)

# Suppose your project builds mainly on papers 1 and 3
seeds = [1, 3]
cov_r1 = coverage(G, seeds, r=1)
cov_r2 = coverage(G, seeds, r=2)
print("\nCoverage with seeds", seeds)
print("r=1:", cov_r1)
print("r=2:", cov_r2)
      

In a realistic workflow you would populate projects and the graph G from bibliographic databases (e.g. BibTeX exports) rather than hard-coding them, but the mathematical structure remains the same.

The same utility-based scoring can be implemented in C++ for integration into a larger robotics codebase (e.g. a planning framework where project ideas correspond to specific algorithmic configurations).

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

struct Project {
    std::string name;
    double I_norm;
    double A_norm;
    double D_norm;
    double R_norm;
};

struct Weights {
    double lambda_I;
    double lambda_A;
    double lambda_D;
    double lambda_R;
};

double utility(const Project& p, const Weights& w) {
    return w.lambda_I * p.I_norm
         + w.lambda_A * p.A_norm
         - w.lambda_D * p.D_norm
         - w.lambda_R * p.R_norm;
}

int main() {
    std::vector<Project> projects = {
        {"Kinodynamic RRT* with risk-sensitive cost", 0.8, 0.9, 0.7, 0.6},
        {"Task and motion planning for pick-place",    0.7, 0.8, 0.5, 0.4},
        {"Swarm coverage with formal specs",           0.9, 0.7, 0.9, 0.8}
    };

    Weights w {0.4, 0.3, 0.2, 0.1};

    double bestScore = -1e9;
    int bestIndex = -1;

    for (std::size_t i = 0; i < projects.size(); ++i) {
        double score = utility(projects[i], w);
        if (score > bestScore) {
            bestScore = score;
            bestIndex = static_cast<int>(i);
        }
    }

    if (bestIndex >= 0) {
        std::cout << "Best project: " << projects[bestIndex].name
                  << " with score " << bestScore << std::endl;
    }
    return 0;
}
      

In a capstone implementation, you might expose Project instances through a GUI where students tune Weights interactively to explore the tradeoffs between impact, alignment, difficulty, and risk.

In Java, a typical pattern is to encapsulate scoring logic in a class, which can later be used in Android-based tools or desktop applications that help manage project ideas and literature.

public class Project {
    private final String name;
    private final double I_norm;
    private final double A_norm;
    private final double D_norm;
    private final double R_norm;

    public Project(String name, double I_norm, double A_norm,
                   double D_norm, double R_norm) {
        this.name = name;
        this.I_norm = I_norm;
        this.A_norm = A_norm;
        this.D_norm = D_norm;
        this.R_norm = R_norm;
    }

    public String getName() {
        return name;
    }

    public double utility(Weights w) {
        return w.lambdaI * I_norm
             + w.lambdaA * A_norm
             - w.lambdaD * D_norm
             - w.lambdaR * R_norm;
    }

    public static class Weights {
        public double lambdaI;
        public double lambdaA;
        public double lambdaD;
        public double lambdaR;
    }

    public static void main(String[] args) {
        Project p1 = new Project("Kinodynamic RRT* with risk-sensitive cost",
                                 0.8, 0.9, 0.7, 0.6);
        Project p2 = new Project("Task and motion planning for pick-place",
                                 0.7, 0.8, 0.5, 0.4);

        Weights w = new Weights();
        w.lambdaI = 0.4;
        w.lambdaA = 0.3;
        w.lambdaD = 0.2;
        w.lambdaR = 0.1;

        Project best = p1.utility(w) > p2.utility(w) ? p1 : p2;
        System.out.println("Best project: " + best.getName());
    }
}
      

You can extend this design with additional fields (e.g. a list of key papers or BibTeX keys) and methods for updating normalized metrics as your literature map evolves.

MATLAB is particularly convenient for manipulating adjacency matrices representing citation graphs and for sketching system-level block diagrams in Simulink once a project is chosen.

% Toy adjacency matrix for 5 theoretical robotics papers
% A(i,j) = 1 if paper i cites paper j
A = [
    0 1 1 0 0;
    0 0 1 0 0;
    0 1 0 1 0;
    0 0 0 0 1;
    0 0 0 0 0
];

G = digraph(A);
figure;
plot(G);
title('Citation graph (toy example)');

% Simple out-degree and in-degree
d_out = outdegree(G);
d_in  = indegree(G);

% PageRank-style centrality (R2022b and later)
pr = centrality(G, 'pagerank', 'Importance', G.Edges.Weight);

disp('PageRank centrality:');
disp(pr.');

% Coverage for a chosen seed set S = {1,3} and radius r = 1
seeds = [1 3];
r = 1;
reachable = bfsearch(G, seeds, 'edgetonew');
cov_r1 = numel(unique(reachable)) / numnodes(G);
fprintf('Coverage for seeds {1,3}, r=1: %.3f\n', cov_r1);

% Once a project is selected, you can create a Simulink model shell:
% new_system('CapstoneRobotSystem');
% open_system('CapstoneRobotSystem');
% Use Simulink blocks to represent sensing, planning, control, and execution layers.
      

In later capstone lessons, Simulink models can reflect the overall autonomy architecture chosen for the project. Here it mainly provides a convenient graphical scaffold for organizing the modules implied by your problem definition.

Mathematica offers concise syntax for constructing graphs and computing centralities, which can be useful for theoretical exploration of literature structures.

(* Define a directed citation graph with vertex labels *)
papers = {
  1 -> "RRT* optimal kinodynamic planning",
  2 -> "PRM* asymptotic optimality",
  3 -> "Risk-sensitive planning",
  4 -> "Formal methods for planning",
  5 -> "RL for continuous control"
};

edges = {
  1 -> 2,
  3 -> 1,
  3 -> 2,
  4 -> 1,
  4 -> 3,
  5 -> 3,
  5 -> 2
};

g = Graph[edges, VertexLabels -> papers];

(* PageRank centrality *)
pr = PageRankCentrality[g];

(* Normalize PageRank and display as association from label to score *)
labels = PropertyValue[{g, #}, VertexLabels] & /@ VertexList[g];
assoc = AssociationThread[labels, pr/Total[pr]];
assoc

(* Simple coverage computation for seeds {1,3} and radius r=1 *)
rNeighborhood[g_, seeds_List, r_Integer] := Module[{S = seeds, frontier = seeds, depth = 0},
  While[depth < r && frontier =!= {},
    frontier = VertexOutComponent[g, frontier, 1] ~Complement~ S;
    S = Union[S, frontier];
    depth++;
  ];
  S
];

seeds = {1, 3};
S1 = rNeighborhood[g, seeds, 1];
coverage = N[Length[S1]/VertexCount[g]]
      

This style of symbolic exploration is well suited for reasoning about idealized or asymptotic properties of literature structures, such as how centrality measures behave under graph operations (e.g. adding or removing influential papers).

Problem 1 (Bounds on the Utility Score): Consider the utility \( U(p;\boldsymbol{\lambda}) \) defined as

\[ U(p;\boldsymbol{\lambda}) = \lambda_I \tilde{I}(p) + \lambda_A \tilde{A}(p) - \lambda_D \tilde{D}(p) - \lambda_R \tilde{R}(p), \]

where each normalized metric satisfies \( \tilde{I}(p), \tilde{A}(p), \tilde{D}(p), \tilde{R}(p) \in [0,1] \) and \( \lambda_I,\lambda_A,\lambda_D,\lambda_R \ge 0 \). Show that for all projects \( p \) we have

\[ -(\lambda_D + \lambda_R) \;\le\; U(p;\boldsymbol{\lambda}) \;\le\; \lambda_I + \lambda_A. \]

Solution:

Since \( \tilde{I}(p),\tilde{A}(p) \in [0,1] \) and the corresponding weights are non-negative, we have

\[ 0 \le \lambda_I \tilde{I}(p) \le \lambda_I, \qquad 0 \le \lambda_A \tilde{A}(p) \le \lambda_A. \]

Similarly, for the difficulty and risk terms we obtain

\[ 0 \le \lambda_D \tilde{D}(p) \le \lambda_D, \qquad 0 \le \lambda_R \tilde{R}(p) \le \lambda_R. \]

Therefore,

\[ \lambda_I \tilde{I}(p) + \lambda_A \tilde{A}(p) \le \lambda_I + \lambda_A, \]

and

\[ -\lambda_D \tilde{D}(p) - \lambda_R \tilde{R}(p) \ge -(\lambda_D + \lambda_R). \]

Adding the inequalities yields \( -(\lambda_D + \lambda_R) \le U(p;\boldsymbol{\lambda}) \le \lambda_I + \lambda_A \), completing the proof.

Problem 2 (Monotonicity of Coverage): Let \( G = (V,E) \) be a directed citation graph with \( |V| = m \), and define the \( r \)-neighborhood \( \mathcal{N}_r(S) \) and coverage fraction \( \operatorname{cov}_r(S) \) as in Section 5. Prove that if \( S \subseteq T \subseteq V \), then \( \operatorname{cov}_r(S) \le \operatorname{cov}_r(T) \).

Solution:

By definition, \( \mathcal{N}_r(S) \) is the set of vertices within graph distance at most \( r \) from at least one element of \( S \), and similarly for \( \mathcal{N}_r(T) \). Because \( S \subseteq T \), any path of length at most \( r \) starting from a vertex in \( S \) is also a path starting from a vertex in \( T \). Thus every vertex reachable from \( S \) in at most \( r \) steps is also reachable from \( T \), which implies \( \mathcal{N}_r(S) \subseteq \mathcal{N}_r(T) \). Taking cardinalities and dividing by \( |V| \) gives

\[ \operatorname{cov}_r(S) = \frac{|\mathcal{N}_r(S)|}{|V|} \le \frac{|\mathcal{N}_r(T)|}{|V|} = \operatorname{cov}_r(T), \]

which proves monotonicity.

Problem 3 (Jaccard Similarity Bounds): Let \( K_1 \) and \( K_2 \) be the sets of keywords associated with two robotics papers. The Jaccard similarity is

\[ J(K_1,K_2) = \frac{|K_1 \cap K_2|}{|K_1 \cup K_2|}. \]

Show that \( 0 \le J(K_1,K_2) \le 1 \), and interpret the extreme values in terms of literature mapping.

Solution:

Since \( K_1 \cap K_2 \subseteq K_1 \cup K_2 \), we have \( |K_1 \cap K_2| \le |K_1 \cup K_2| \). Moreover cardinalities are non-negative, so \( 0 \le |K_1 \cap K_2| \le |K_1 \cup K_2| \). Thus

\[ 0 \le \frac{|K_1 \cap K_2|}{|K_1 \cup K_2|} \le 1, \]

as required. If \( J(K_1,K_2) = 1 \), the two papers share exactly the same keyword set, which means they occupy an almost identical conceptual niche in the literature map. If \( J(K_1,K_2) = 0 \), they share no keywords and likely belong to distinct clusters (e.g. one in sampling-based planning, the other in deformable-object manipulation), suggesting that a project that connects the two could be highly cross-cutting.

Problem 4 (Numerical Example of Project Selection): Suppose you have three candidate projects whose normalized metrics (already in \( [0,1] \)) are:

\[ \begin{aligned} p_1:&   \tilde{I} = 0.7,\; \tilde{A} = 0.9,\; \tilde{D} = 0.6,\; \tilde{R} = 0.4,\\ p_2:&   \tilde{I} = 0.9,\; \tilde{A} = 0.6,\; \tilde{D} = 0.8,\; \tilde{R} = 0.7,\\ p_3:&   \tilde{I} = 0.6,\; \tilde{A} = 0.8,\; \tilde{D} = 0.4,\; \tilde{R} = 0.3. \end{aligned} \]

With weights \( \lambda_I = 0.5,\; \lambda_A = 0.3,\; \lambda_D = 0.1,\; \lambda_R = 0.1 \), compute \( U(p_i;\boldsymbol{\lambda}) \) for \( i=1,2,3 \) and determine the best project.

Solution:

For \( p_1 \):

\[ U(p_1;\boldsymbol{\lambda}) = 0.5 \cdot 0.7 + 0.3 \cdot 0.9 - 0.1 \cdot 0.6 - 0.1 \cdot 0.4 = 0.35 + 0.27 - 0.06 - 0.04 = 0.52. \]

For \( p_2 \):

\[ U(p_2;\boldsymbol{\lambda}) = 0.5 \cdot 0.9 + 0.3 \cdot 0.6 - 0.1 \cdot 0.8 - 0.1 \cdot 0.7 = 0.45 + 0.18 - 0.08 - 0.07 = 0.48. \]

For \( p_3 \):

\[ U(p_3;\boldsymbol{\lambda}) = 0.5 \cdot 0.6 + 0.3 \cdot 0.8 - 0.1 \cdot 0.4 - 0.1 \cdot 0.3 = 0.30 + 0.24 - 0.04 - 0.03 = 0.47. \]

The utilities are \( U(p_1) = 0.52 \), \( U(p_2) = 0.48 \), \( U(p_3) = 0.47 \). Under this particular weighting of impact, alignment, difficulty, and risk, project \( p_1 \) is the best choice.

In this lesson we formalized capstone problem selection as a multi-criteria decision problem over candidate project definitions, grounded in the control and planning formulations used throughout the course. We modeled the robotics literature as both a citation graph and a metric space, enabling analytic notions of centrality, coverage, novelty, and gap scores. Simple but powerful scalarizations such as \( U(p;\boldsymbol{\lambda}) \) and \( G(p) \) allow you to systematize what is often an informal process of choosing “interesting” and “feasible” projects. The accompanying Python, C++, Java, MATLAB/Simulink, and Mathematica snippets illustrate how these abstractions can be implemented in code to support rigorous project planning.

Subsequent lessons in this chapter will treat the chosen project as fixed and focus on system architecture, implementation, and experimental validation consistent with the literature and metrics introduced here.