The capstone project integrates planning, learning, and control methods studied in previous chapters into a coherent autonomous system. The final demo is an operational validation: a physical or simulated robot executes tasks drawn from a task family under specified conditions. The research-style paper is an analytical validation: it formalizes assumptions, defines performance metrics, and supports claims with mathematically sound experiments and statistical evidence.

Let the autonomous stack implement a policy \( \pi \) that selects actions from observations in a task distribution \( \mathcal{T} \). For a task instance \( \tau \in \mathcal{T} \), an episode produces a trajectory \( \mathbf{x}_{0:H} \) and control sequence \( \mathbf{u}_{0:H-1} \). A performance functional \( J \) maps each trajectory to a scalar score:

\[ J(\pi) \triangleq \mathbb{E}_{\tau \sim \mathcal{T}} \Big[\,\mathbb{E}\big[\,R(\mathbf{x}_{0:H}, \mathbf{u}_{0:H-1}) \,\big|\, \pi, \tau \big]\,\Big] \]

where \( R \) may encode success/failure, path quality, energy usage, or a weighted combination thereof. The final demo visually illustrates that \( J(\pi) \) is high on representative tasks; the paper reports an estimate of \( J(\pi) \) together with uncertainty quantification and principled baselines.

For the capstone, two classes of metrics are fundamental: (i) binary success metrics, and (ii) real-valued quality metrics (e.g., time, cost, smoothness). Suppose each experimental trial produces a random variable \( Y \) under policy \( \pi \).

For binary success, \( Y \in \{0,1\} \), with success probability \( p^\star = \mathbb{P}(Y=1) \). For real-valued quality we assume \( Y \in [a,b] \) with finite mean \( \mu^\star = \mathbb{E}[Y] \) and variance \( \sigma^{2\star} = \operatorname{Var}(Y) \).

From \( N \) i.i.d. trials we obtain samples \( Y_1,\dots,Y_N \), yielding the empirical mean

\[ \hat{\mu}_N \triangleq \frac{1}{N}\sum_{i=1}^{N} Y_i, \qquad \hat{\sigma}_N^2 \triangleq \frac{1}{N-1}\sum_{i=1}^{N} \big(Y_i - \hat{\mu}_N\big)^2. \]

For binary success, define the empirical success rate

\[ \hat{p}_N \triangleq \frac{1}{N}\sum_{i=1}^{N} \mathbf{1}\{Y_i = 1\}. \]

These estimators are unbiased: \( \mathbb{E}[\hat{\mu}_N] = \mu^\star \) and \( \mathbb{E}[\hat{p}_N] = p^\star \). The variance of the empirical success rate is

\[ \operatorname{Var}(\hat{p}_N) = \frac{p^\star(1-p^\star)}{N} \;\le\; \frac{1}{4N}, \]

since \( p^\star(1-p^\star) \le 1/4 \) for all \( p^\star \in [0,1] \). This upper bound is useful for sample-complexity guarantees independent of the unknown true success probability.

In many capstone projects the metric is a weighted combination of sub-metrics (success, time, safety violations, energy, etc.). Let \( \mathbf{m} \in \mathbb{R}^d \) denote a metric vector and \( \mathbf{w} \in \mathbb{R}^d \) a nonnegative weight vector with \( \sum_{j=1}^{d} w_j = 1 \). The scalar score is

\[ S \triangleq \mathbf{w}^\top \mathbf{m} \quad\Rightarrow\quad \mathbb{E}[S] = \mathbf{w}^\top \mathbb{E}[\mathbf{m}], \qquad \operatorname{Var}(S) = \mathbf{w}^\top \operatorname{Cov}(\mathbf{m}) \,\mathbf{w}. \]

Choosing \( \mathbf{w} \) is therefore a modeling decision which should be justified in the paper (e.g., emphasizing safety over speed).

To make statistically meaningful claims in the paper (e.g., “our method succeeds on 90% of tasks”), we must attach a confidence interval or hypothesis test derived from the experimental data.

3.1 Approximate confidence interval for success rate

For moderately large \( N \), the central limit theorem gives \( \hat{p}_N \approx \mathcal{N}\big(p^\star, \tfrac{p^\star(1-p^\star)}{N}\big) \). Replacing \( p^\star \) with \( \hat{p}_N \), a two-sided \( (1-\alpha) \) confidence interval is

\[ \hat{p}_N \;\pm\; z_{1-\alpha/2} \sqrt{\frac{\hat{p}_N(1-\hat{p}_N)}{N}}, \]

where \( z_{1-\alpha/2} \) is the corresponding Gaussian quantile (e.g., \( z_{0.975} \approx 1.96 \) for 95% confidence).

3.2 PAC-style guarantee via Hoeffding's inequality

For bounded \( Y_i \in [0,1] \) (e.g., binary success), Hoeffding's inequality yields for any \( \epsilon > 0 \), \( \delta \in (0,1) \):

\[ \mathbb{P}\Big(\big|\hat{p}_N - p^\star\big| \;>\; \epsilon\Big) \;\le\; 2 \exp\big(-2N\epsilon^2\big) \;\le\; \delta. \]

Solving for \( N \) gives the sufficient number of trials

\[ N \;\ge\; \frac{1}{2\epsilon^2}\,\log\!\Big(\frac{2}{\delta}\Big). \]

This formula can be evaluated symbolically (e.g., in Wolfram Mathematica) or numerically (e.g., in Python/MATLAB) when planning the size of your final demo experiment.

3.3 Comparing two methods

Suppose you compare your method \( A \) with a baseline \( B \) using \( N_A \) and \( N_B \) independent trials, giving empirical success rates \( \hat{p}_A \) and \( \hat{p}_B \). Under a null hypothesis \( H_0: p_A = p_B \), the pooled success rate is

\[ \hat{p}_{\text{pool}} \triangleq \frac{N_A \hat{p}_A + N_B \hat{p}_B}{N_A + N_B}, \]

and the test statistic is

\[ Z \triangleq \frac{\hat{p}_A - \hat{p}_B} { \sqrt{\hat{p}_{\text{pool}}(1-\hat{p}_{\text{pool}}) \big(\tfrac{1}{N_A}+\tfrac{1}{N_B}\big)} }. \]

Under \( H_0 \) and for large sample sizes, \( Z \approx \mathcal{N}(0,1) \), enabling a two-sided test at level \( \alpha \) by checking whether \( |Z| > z_{1-\alpha/2} \). Stating this clearly in the paper (including \( N_A, N_B, \hat{p}_A, \hat{p}_B, Z, \alpha \)) moves your evaluation beyond anecdotal demos.

The final demo should be the visible tip of an evaluation pipeline that is fully reproducible. At minimum, your system should support: (i) deterministic configuration of software versions and parameters; (ii) scripted scenario generation; (iii) automatic logging of metrics; and (iv) repeatable plotting and statistical analysis.

flowchart TD
  A["Specify task family and metrics"] --> B["Define scenarios and random seeds"]
  B --> C["Run scripted experiments (simulation or real robot)"]
  C --> D["Log trajectories and metrics to files"]
  D --> E["Post-process logs: compute estimates and intervals"]
  E --> F["Select representative trials for live demo"]
  E --> G["Generate plots and tables for paper"]
  F --> H["Final demo session"]
  G --> I["Paper: methods + experiments section"]
        

The research paper should document every step of this flow so that another group could, in principle, reproduce your results with access to your code and environment.

While specific venues impose format constraints, a common structure for robotics papers is: (i) Abstract; (ii) Introduction; (iii) Related Work; (iv) Problem Formulation; (v) Method; (vi) Experiments; (vii) Discussion; (viii) Conclusion.

5.1 Problem formulation and method

In the problem formulation, define the state space \( \mathcal{X} \), control space \( \mathcal{U} \), disturbance space \( \mathcal{W} \) (if any), and task distribution \( \mathcal{T} \). The dynamics model \( f \) is usually of the form

\[ \mathbf{x}_{t+1} = f(\mathbf{x}_t, \mathbf{u}_t, \mathbf{w}_t), \qquad \mathbf{w}_t \sim \mathcal{D}_w. \]

Your method section should re-use notation from this formulation, e.g., a planner \( \mathcal{P} \) mapping an initial state and goal to a trajectory, or a policy parameter vector \( \theta \) defining \( \pi_\theta(\mathbf{u}_t \mid \mathbf{o}_{0:t}) \).

5.2 Experiments and ablations

The experiments section should:

• Define all baselines and hyperparameters.
• State which random seeds and how many trials per setting were used.
• Report metrics as \( \hat{\mu}_N \pm \text{CI} \) or with p-values from formal tests.
• Include ablation studies where key model components are removed.

For an ablation comparing a full method \( A \) and a variant \( B \), you may report the relative improvement in mean score as

\[ \Delta_{\text{rel}} \triangleq \frac{\hat{\mu}_A - \hat{\mu}_B}{|\hat{\mu}_B| + \varepsilon}, \]

where \( \hat{\mu}_A, \hat{\mu}_B \) are the empirical means and \( \varepsilon > 0 \) is a small regularizer (e.g., \( 10^{-6} \)) to avoid division by zero. If you propagate uncertainty through \( \Delta_{\text{rel}} \), you can use a first-order approximation (delta method) or bootstrap.

This section provides concise templates in multiple languages for running final evaluation experiments, computing confidence intervals, and generating summary figures or tables for the paper. The robotics-specific components (planners, controllers, simulators) are abstracted as callable interfaces.

6.1 Python: Evaluation and Confidence Interval

import numpy as np
from typing import Callable, Dict, Any

# Assume env has methods: reset(task), step(u), is_done(), get_metrics()
# and policy has method act(obs)

def run_episode(env, policy, task_config: Dict[str, Any], max_steps: int = 500):
    obs = env.reset(task_config)
    success = 0
    metrics_accum = []
    for t in range(max_steps):
        u = policy.act(obs)
        obs, reward, done, info = env.step(u)
        metrics_accum.append(info.get("step_cost", 0.0))
        if done:
            success = 1 if info.get("success", False) else 0
            break
    episode_time = info.get("elapsed_time", t + 1)
    energy = info.get("energy_used", float(np.sum(metrics_accum)))
    return {"success": success, "time": episode_time, "energy": energy}

def evaluate_policy(env, policy, tasks: Callable[[int], Dict[str, Any]],
                    n_trials: int = 100, alpha: float = 0.05):
    successes = []
    times = []
    energies = []
    for i in range(n_trials):
        cfg = tasks(i)
        result = run_episode(env, policy, cfg)
        successes.append(result["success"])
        times.append(result["time"])
        energies.append(result["energy"])

    successes = np.asarray(successes, dtype=float)
    times = np.asarray(times, dtype=float)
    energies = np.asarray(energies, dtype=float)

    p_hat = successes.mean()
    # Wald-type CI for success rate
    z = 1.96  # for 95% confidence
    se_p = np.sqrt(p_hat * (1.0 - p_hat) / len(successes))
    ci_low = p_hat - z * se_p
    ci_high = p_hat + z * se_p

    return {
        "p_hat": p_hat,
        "p_ci": (max(0.0, ci_low), min(1.0, ci_high)),
        "time_mean": times.mean(),
        "time_std": times.std(ddof=1),
        "energy_mean": energies.mean(),
        "energy_std": energies.std(ddof=1),
    }

if __name__ == "__main__":
    # env, policy, and tasks(...) must be provided by your project
    stats = evaluate_policy(env, policy, tasks, n_trials=50)
    print("Success rate:", stats["p_hat"], "CI95:", stats["p_ci"])
    print("Mean time:", stats["time_mean"], "+/-", stats["time_std"])
    print("Mean energy:", stats["energy_mean"], "+/-", stats["energy_std"])
      

6.2 C++: Aggregating Metrics (e.g., with Eigen)

#include <iostream>
#include <vector>
#include <cmath>

struct EpisodeMetrics {
    int success;
    double time;
    double energy;
};

struct EvalStats {
    double p_hat;
    double p_ci_low;
    double p_ci_high;
    double time_mean;
    double time_std;
    double energy_mean;
    double energy_std;
};

EvalStats compute_stats(const std::vector<EpisodeMetrics>& data) {
    const std::size_t N = data.size();
    double sum_success = 0.0;
    double sum_time = 0.0, sum_time2 = 0.0;
    double sum_energy = 0.0, sum_energy2 = 0.0;

    for (const auto& e : data) {
        sum_success += static_cast<double>(e.success);
        sum_time += e.time;
        sum_time2 += e.time * e.time;
        sum_energy += e.energy;
        sum_energy2 += e.energy * e.energy;
    }

    EvalStats out{};
    out.p_hat = sum_success / static_cast<double>(N);

    const double z = 1.96; // 95% CI
    const double se_p = std::sqrt(out.p_hat * (1.0 - out.p_hat) / static_cast<double>(N));
    out.p_ci_low = std::max(0.0, out.p_hat - z * se_p);
    out.p_ci_high = std::min(1.0, out.p_hat + z * se_p);

    out.time_mean = sum_time / static_cast<double>(N);
    out.energy_mean = sum_energy / static_cast<double>(N);

    if (N > 1) {
        const double var_time =
            (sum_time2 - static_cast<double>(N) * out.time_mean * out.time_mean)
            / static_cast<double>(N - 1);
        const double var_energy =
            (sum_energy2 - static_cast<double>(N) * out.energy_mean * out.energy_mean)
            / static_cast<double>(N - 1);
        out.time_std = std::sqrt(std::max(0.0, var_time));
        out.energy_std = std::sqrt(std::max(0.0, var_energy));
    }

    return out;
}

int main() {
    std::vector<EpisodeMetrics> log;
    // TODO: fill log from your simulator or robot runs
    EvalStats stats = compute_stats(log);
    std::cout << "Success rate: " << stats.p_hat
              << " CI95: [" << stats.p_ci_low
              << ", " << stats.p_ci_high << "]\n";
    return 0;
}
      

6.3 Java: Logging and Summary

public class EpisodeMetrics {
    public int success;
    public double time;
    public double energy;
    public EpisodeMetrics(int success, double time, double energy) {
        this.success = success;
        this.time = time;
        this.energy = energy;
    }
}

public class EvalStats {
    public double pHat, pCiLow, pCiHigh;
    public double timeMean, timeStd;
    public double energyMean, energyStd;
}

public class Evaluator {

    public static EvalStats computeStats(java.util.List<EpisodeMetrics> data) {
        int N = data.size();
        double sumSuccess = 0.0;
        double sumTime = 0.0, sumTime2 = 0.0;
        double sumEnergy = 0.0, sumEnergy2 = 0.0;

        for (EpisodeMetrics e : data) {
            sumSuccess += (double)e.success;
            sumTime += e.time;
            sumTime2 += e.time * e.time;
            sumEnergy += e.energy;
            sumEnergy2 += e.energy * e.energy;
        }

        EvalStats out = new EvalStats();
        out.pHat = sumSuccess / (double)N;

        double z = 1.96;
        double seP = Math.sqrt(out.pHat * (1.0 - out.pHat) / (double)N);
        out.pCiLow = Math.max(0.0, out.pHat - z * seP);
        out.pCiHigh = Math.min(1.0, out.pHat + z * seP);

        out.timeMean = sumTime / (double)N;
        out.energyMean = sumEnergy / (double)N;

        if (N > 1) {
            double varTime =
                (sumTime2 - (double)N * out.timeMean * out.timeMean) / (double)(N - 1);
            double varEnergy =
                (sumEnergy2 - (double)N * out.energyMean * out.energyMean) / (double)(N - 1);
            out.timeStd = Math.sqrt(Math.max(0.0, varTime));
            out.energyStd = Math.sqrt(Math.max(0.0, varEnergy));
        }

        return out;
    }

    public static void main(String[] args) {
        java.util.List<EpisodeMetrics> log = new java.util.ArrayList<>();
        // TODO: populate log from your experiment runner
        EvalStats stats = computeStats(log);
        System.out.println("Success rate: " + stats.pHat +
                           " CI95: [" + stats.pCiLow + ", " + stats.pCiHigh + "]");
    }
}
      

6.4 MATLAB / Simulink: Batch Simulation and Statistics

function stats = evaluate_policy_sim(modelName, taskGenerator, N)
% modelName: name of Simulink model
% taskGenerator(i): returns struct of parameters for trial i

success = zeros(N,1);
timeVec = zeros(N,1);
energyVec = zeros(N,1);

for k = 1:N
    cfg = taskGenerator(k); % user-defined function returning config struct
    % Assign configuration to base workspace or model parameters
    assignin('base', 'taskConfig', cfg);

    simOut = sim(modelName, 'SaveOutput', 'on', 'SaveState', 'off');
    logs = simOut.logsout;
    % Assume logs contains signals "success", "episodeTime", "energy"
    success(k) = logs.get('success').Values.Data(end);
    timeVec(k) = logs.get('episodeTime').Values.Data(end);
    energyVec(k) = logs.get('energy').Values.Data(end);
end

p_hat = mean(success);
z = 1.96;
se_p = sqrt(p_hat*(1-p_hat)/N);
stats.p_hat = p_hat;
stats.p_ci = [max(0, p_hat - z*se_p), min(1, p_hat + z*se_p)];

stats.time_mean = mean(timeVec);
stats.time_std = std(timeVec, 1);    % population or sample as desired
stats.energy_mean = mean(energyVec);
stats.energy_std = std(energyVec, 1);
end
      

6.5 Wolfram Mathematica: Solving for Required Sample Size

(* Given epsilon and delta, solve N from Hoeffding bound *)
Clear[requiredN];
requiredN[eps_, delta_] :=
  Ceiling[(1/(2*eps^2))*Log[2/delta]];

(* Example: epsilon = 0.05, delta = 0.05 *)
eps = 0.05;
delta = 0.05;
nRequired = requiredN[eps, delta];

Print["Required N for Hoeffding bound: ", nRequired];

(* Symbolic CI width for success probability p *)
Clear[ciWidth];
ciWidth[p_, n_, alpha_] :=
  Module[{z},
    z = InverseCDF[NormalDistribution[0,1], 1 - alpha/2];
    2*z*Sqrt[p*(1 - p)/n]
  ];

(* Inspect worst-case CI width over p in [0,1] *)
maxWidth = Maximize[{ciWidth[p, nRequired, 0.05], 0 <= p <= 1}, p]
      

Mathematica is especially useful for symbolic manipulations (e.g., bounding worst-case confidence interval widths) that you can subsequently reference in the theory or experiment-design sections of your paper.

Problem 1 (Sample complexity for final demo): You want to report your capstone success rate with additive error at most \( \epsilon = 0.05 \) and confidence at least \( 1-\delta = 0.95 \). Using Hoeffding's inequality, compute a sufficient number of trials \( N \).

Solution: From Section 3.2, a sufficient condition is

\[ N \;\ge\; \frac{1}{2\epsilon^2}\,\log\!\Big(\frac{2}{\delta}\Big). \]

Plugging in \( \epsilon = 0.05 \) and \( \delta = 0.05 \) gives

\[ N \;\ge\; \frac{1}{2 \cdot 0.05^2}\,\log\!\Big(\frac{2}{0.05}\Big) = \frac{1}{2 \cdot 0.0025}\,\log(40) = 200 \,\log(40). \]

Since \( \log(40) \approx 3.6889 \), we obtain \( N \gtrsim 737.8 \). Rounding up, \( N = 738 \) trials suffices. In practice, you may choose a smaller \( N \) if you accept weaker worst-case guarantees or use approximate (Gaussian) intervals.

Problem 2 (Confidence interval interpretation): In your final experiments you obtain \( \hat{p}_N = 0.9 \) from \( N = 50 \) trials. Construct the 95% approximate confidence interval, and interpret whether “the policy has success rate at least 80%” is supported.

Solution: The standard error is

\[ \operatorname{se}(\hat{p}_N) = \sqrt{\frac{\hat{p}_N(1-\hat{p}_N)}{N}} = \sqrt{\frac{0.9 \cdot 0.1}{50}} = \sqrt{\frac{0.09}{50}} \approx \sqrt{0.0018} \approx 0.0424. \]

With \( z_{0.975} \approx 1.96 \), the 95% interval is

\[ 0.9 \pm 1.96 \cdot 0.0424 \approx 0.9 \pm 0.083. \]

Thus the interval is approximately \( [0.817,\; 0.983] \). The claim “success rate is at least 80%” is consistent with this interval (80% lies below the lower bound, so the data actually support a stronger claim that the rate exceeds roughly 81.7% at 95% confidence). In the paper you would state both point estimate and interval.

Problem 3 (Comparing with a baseline): Your method A achieves \( \hat{p}_A = 0.86 \) over \( N_A = 100 \) trials, while baseline B achieves \( \hat{p}_B = 0.76 \) over \( N_B = 100 \) trials. Perform a large-sample two-sided z-test for equality of success probabilities at \( \alpha = 0.05 \).

Solution: The pooled success rate is

\[ \hat{p}_{\text{pool}} = \frac{N_A \hat{p}_A + N_B \hat{p}_B}{N_A + N_B} = \frac{100 \cdot 0.86 + 100 \cdot 0.76}{200} = \frac{86 + 76}{200} = \frac{162}{200} = 0.81. \]

The standard error is

\[ \operatorname{se} = \sqrt{\hat{p}_{\text{pool}}(1-\hat{p}_{\text{pool}}) \Big(\frac{1}{N_A}+\frac{1}{N_B}\Big)} = \sqrt{0.81 \cdot 0.19 \cdot \frac{2}{100}} = \\ \sqrt{0.1539 \cdot 0.02} = \sqrt{0.003078} \approx 0.0555. \]

The test statistic is

\[ Z = \frac{\hat{p}_A - \hat{p}_B}{\operatorname{se}} = \frac{0.86 - 0.76}{0.0555} \approx \frac{0.10}{0.0555} \approx 1.80. \]

For \( \alpha = 0.05 \), \( z_{0.975} \approx 1.96 \). Since \( |Z| \approx 1.80 < 1.96 \), we do not reject \( H_0 \). The improvement trend is positive but not statistically significant at 5%; in the paper, this caveat should be made explicit.

Problem 4 (Weighted metric variance): Suppose you aggregate two metrics, \( m_1 \) (success probability) and \( m_2 \) (negative path length), into \( S = w_1 m_1 + w_2 m_2 \) with \( w_1 + w_2 = 1 \), \( w_1,w_2 \ge 0 \). Let \( \operatorname{Var}(m_1) = \sigma_1^2 \), \( \operatorname{Var}(m_2) = \sigma_2^2 \), and \( \operatorname{Cov}(m_1,m_2) = \rho \sigma_1 \sigma_2 \). Derive \( \operatorname{Var}(S) \).

Solution: Using bilinearity of covariance,

\[ \operatorname{Var}(S) = \operatorname{Var}(w_1 m_1 + w_2 m_2) = w_1^2 \sigma_1^2 + w_2^2 \sigma_2^2 + 2 w_1 w_2 \operatorname{Cov}(m_1,m_2). \]

Substituting the covariance,

\[ \operatorname{Var}(S) = w_1^2 \sigma_1^2 + w_2^2 \sigma_2^2 + 2 w_1 w_2 \rho \sigma_1 \sigma_2. \]

This expression shows explicitly how correlation between metrics affects the variability of the combined score. In your paper, you could plug in empirical estimates of \( \sigma_1^2, \sigma_2^2, \rho \).

Problem 5 (Reporting negative results): Your improved planner does not significantly outperform a simpler baseline under the tests above, but it has better worst-case guarantees proved theoretically. Outline how you would honestly report this in the paper.

Solution: A rigorous report should:

• State the theoretical guarantee precisely (e.g., asymptotic optimality or tighter suboptimality bound).
• Present empirical results showing that on the tested distribution of tasks, performance differences are within confidence intervals.
• Discuss possible mismatch between the theoretical assumptions and the experimental regime.
• Frame the contribution as providing stronger guarantees without hurting performance, rather than as an empirically dominant method.

Such transparent reporting is expected in research-grade robotics work and strengthens the credibility of your final demo and paper.

In this lesson we framed the capstone final demo as a statistically grounded evaluation of an autonomous system, not just a one-off showcase. We modeled binary and real-valued metrics, derived confidence intervals and sample-complexity bounds, and discussed how to compare your method to baselines using hypothesis tests. We then mapped these ideas into the structure of a research-style robotics paper and provided multi-language templates for running evaluations and summarizing results. With these tools, your final demo and paper can meet the standards of reproducibility and rigor expected in advanced robotics research.