In Lesson 1 we defined robots as embodied systems that can sense, compute, and act. In Lesson 2 we separated robots from simple automation. The remaining key distinction is how much of the sense–compute–act loop is closed by the robot itself.

Informally:

• Autonomy measures how independently the robot achieves goals.
• Intelligence measures how well it chooses actions under uncertainty and change.

flowchart TD
  A["Human does everything"] --> B["Robot assists (shared control)"]
  B --> C["Robot executes tasks autonomously"]
  C --> D["Robot chooses tasks & adapts strategy"]
  D --> E["Robot self-improves / learns new skills"]
        

The diagram above is a qualitative “ladder.” The rest of the lesson makes it quantitative.

Let the robot’s state be \( x(t) \in \mathbb{R}^n \), control input \( u(t)\in\mathbb{R}^m \), and environment disturbance \( w(t)\in\mathbb{R}^p \). A broad class of systems is

\[ \dot{x}(t) = f(x(t),u(t),w(t)), \qquad y(t)=h(x(t)) \]

A robot is autonomous to the extent that it selects \( u(t) \) from internal computation rather than direct human specification. Define:

Definition 2.1 (Human intervention signal). Let \( u_H(t) \) be the human-provided command and \( u_A(t) \) the robot’s internally generated command. A general shared/autonomous law is

\[ u(t)=\alpha(t)\,u_A(t) + \bigl(1-\alpha(t)\bigr)u_H(t), \qquad 0 \le \alpha(t) \le 1. \]

Here \( \alpha(t) \) is an instantaneous autonomy factor. A scalar degree of autonomy over a time horizon \( T \) is

\[ \mathcal{A}_T \triangleq \frac{1}{T}\int_{0}^{T}\alpha(t)\,dt \in [0,1]. \]

Interpretation. \( \mathcal{A}_T=0 \) implies full teleoperation; \( \mathcal{A}_T=1 \) implies full autonomy; intermediate values quantify shared autonomy.

Definition 2.2 (Task-level autonomy). Suppose a task requires a sequence of \( N \) decisions \( d_1,\dots,d_N \). Let \( I_i \in \{0,1\} \) indicate human intervention at decision \( i \) (1 if human intervenes). Then

\[ \mathcal{A}_{task} \triangleq 1-\frac{1}{N}\sum_{i=1}^{N} I_i . \]

This definition is useful for comparing systems across domains: if a robot completes most decisions without intervention, it has high task autonomy even if the physical system differs.

Intelligence is about decision quality under uncertainty. We model autonomy as “who decides,” intelligence as “how good the decision is.”

3.1 Decision as optimization. Let \( \pi \) be a control policy mapping observations to actions: \( u(t)=\pi(o(t)) \), with observation \( o(t) \). Define a task cost functional

\[ J(\pi) \triangleq \mathbb{E}\!\left[\int_{0}^{T} \ell\bigl(x(t),u(t)\bigr)\,dt + \phi(x(T))\right], \]

where \( \ell \) is running cost (energy, tracking error, risk) and \( \phi \) a terminal cost. Higher intelligence means lower achievable cost.

Definition 3.1 (Relative intelligence measure). Given a baseline policy \( \pi_0 \) (e.g., scripted behavior), define

\[ \mathcal{I}(\pi;\pi_0) \triangleq 1-\frac{J(\pi)}{J(\pi_0)}. \]

If \( J(\pi) \lt J(\pi_0) \) then \( \mathcal{I} \gt 0 \), indicating improvement over baseline. The maximal possible intelligence relative to \( \pi_0 \) is 1.

3.2 Adaptivity and information. A minimally intelligent robot may still be autonomous but brittle. To quantify adaptivity, let the environment be a random variable \( E \) and the robot’s internal model be \( M \). Intelligence requires that the robot’s model carries information about the environment:

\[ \text{Mutual Information:}\quad I(E;M) = H(E)-H(E\mid M), \]

where \( H \) is Shannon entropy. If \( I(E;M)=0 \), the model does not reduce uncertainty; the robot cannot adapt meaningfully.

Theorem 3.1 (Learning cannot decrease environment information). Suppose the robot updates its model by conditioning on new data \( D \). Then \( I(E;M,D) \ge I(E;M) \).

Proof. Using chain rules,

\[ I(E;M,D)=I(E;M)+I(E;D\mid M). \]

Since conditional mutual information is nonnegative, \( I(E;D\mid M)\ge 0 \), we obtain \( I(E;M,D) \ge I(E;M) \). □

Therefore, genuine learning (conditioning on real data) can only increase or preserve intelligence in this sense.

Shared autonomy is common in early systems (assistive robots, pilot-assist drones). Because you know linear control, we analyze shared autonomy through stability.

Assume a linear plant (common local approximation): \( \dot{x}=Ax+Bu \). Let \( u_A = Kx \) be an autonomous stabilizing feedback (so \( A+BK \) is Hurwitz) and let \( u_H \) be bounded: \( \|u_H(t)\|\le \bar{u} \). Shared control:

\[ u=\alpha Kx + (1-\alpha)u_H,\qquad 0\le\alpha\le 1. \]

Theorem 4.1 (Input-to-state stability under shared autonomy). If \( A+BK \) is Hurwitz and \( \alpha \gt 0 \), then the shared system is input-to-state stable (ISS) with respect to \( u_H \).

Proof. Consider Lyapunov function \( V(x)=x^TPx \) for some \( P\succ 0 \). Since \( A+BK \) Hurwitz, there exists \( P\succ 0 \) such that

\[ (A+\alpha BK)^T P + P(A+\alpha BK) = -Q,\qquad Q\succ 0. \]

The closed-loop dynamics become \( \dot{x}=(A+\alpha BK)x + B(1-\alpha)u_H \). Then

\[ \dot{V}=x^T\!\bigl[(A+\alpha BK)^TP + P(A+\alpha BK)\bigr]x + 2(1-\alpha)x^TPB u_H = -x^TQx + 2(1-\alpha)x^TPB u_H . \]

Using Cauchy–Schwarz and completing squares, there exists \( c_1,c_2>0 \) such that

\[ \dot{V} \le -c_1\|x\|^2 + c_2\|u_H\|^2. \]

This is the standard ISS Lyapunov inequality, proving ISS. □

Key insight: even partial autonomy (\( \alpha \gt 0 \)) provides a stabilizing backbone as long as the autonomous controller is stabilizing.

We implement a toy shared-autonomy controller for a 1D system \( \dot{x}=u \) with goal \( x \to 0 \). Autonomous feedback uses \( u_A=-kx \). Human command is any bounded signal.

5.1 Python (NumPy)

import numpy as np

def simulate_shared_autonomy(x0=2.0, k=1.5, alpha=0.7, T=5.0, dt=0.01):
    n_steps = int(T/dt)
    x = x0
    xs, us = [x], []

    for t in range(n_steps):
        u_A = -k * x                # autonomous stabilizing feedback
        u_H = 0.5*np.sin(2*np.pi*t*dt)  # example bounded human input
        u   = alpha*u_A + (1-alpha)*u_H

        x += dt*u                   # plant: x_dot = u
        xs.append(x)
        us.append(u)
    return np.array(xs), np.array(us)

xs, us = simulate_shared_autonomy()
print("Final state:", xs[-1])
      

5.2 C++ (Eigen)

#include <iostream>
#include <Eigen/Dense>
#include <cmath>

int main() {
    double x = 2.0, k = 1.5, alpha = 0.7;
    double T = 5.0, dt = 0.01;
    int n_steps = static_cast<int>(T/dt);

    for(int i=0; i < n_steps; ++i){
        double t = i*dt;
        double uA = -k*x;
        double uH = 0.5*std::sin(2*M_PI*t);
        double u  = alpha*uA + (1-alpha)*uH;

        x += dt*u; // x_dot = u
    }
    std::cout << "Final state: " << x << std::endl;
    return 0;
}
      

5.3 Java

public class SharedAutonomy1D {
    public static void main(String[] args){
        double x = 2.0, k = 1.5, alpha = 0.7;
        double T = 5.0, dt = 0.01;
        int nSteps = (int)(T/dt);

        for(int i=0; i < nSteps; i++){
            double t = i*dt;
            double uA = -k*x;
            double uH = 0.5*Math.sin(2*Math.PI*t);
            double u  = alpha*uA + (1-alpha)*uH;

            x += dt*u; // x_dot = u
        }
        System.out.println("Final state: " + x);
    }
}
      

5.4 MATLAB / Simulink-Ready Script

% Shared autonomy for x_dot = u
x = 2.0; k = 1.5; alpha = 0.7;
T = 5.0; dt = 0.01;
nSteps = floor(T/dt);

xs = zeros(nSteps+1,1); xs(1)=x;

for i=1:nSteps
    t  = (i-1)*dt;
    uA = -k*x;
    uH = 0.5*sin(2*pi*t);  % bounded human command
    u  = alpha*uA + (1-alpha)*uH;

    x  = x + dt*u;         % plant integration
    xs(i+1)=x;
end

disp(['Final state: ', num2str(xs(end))]);

% Simulink note:
% Use blocks: Sum, Gain(-k), Sine Wave, Weighted Sum(alpha),
% Integrator for x_dot = u.
      

These minimal examples illustrate how a single scalar \( \alpha \) controls autonomy. Real robots compute \( \alpha(t) \) from confidence, safety, or human intent, which we will revisit later.

Problem 1 (Compute autonomy from intervention log): A robot performs a task requiring \( N=40 \) discrete decisions. A human intervenes in \( 9 \) of them. Compute \( \mathcal{A}_{task} \) and interpret the result.

Solution:

\[ \mathcal{A}_{task} = 1-\frac{1}{40}\sum_{i=1}^{40}I_i = 1-\frac{9}{40} = \frac{31}{40}=0.775. \]

The system is autonomous for about 77.5% of task decisions, indicating substantial but not full autonomy.

Problem 2 (Stability threshold for shared autonomy): Consider \( \dot{x}=ax+bu \), with \( a=1 \), \( b=1 \). The autonomous controller is \( u_A = kx \) with \( k=-3 \). Shared autonomy uses constant \( \alpha \) and bounded \( u_H \). Find the smallest \( \alpha \) that guarantees the autonomous part stabilizes the linear dynamics.

Solution:

Closed-loop linear part: \( \dot{x}=(a+\alpha bk)x + b(1-\alpha)u_H \). Stability requires \( a+\alpha bk \lt 0 \).

\[ 1+\alpha(1)(-3) \lt 0 \;\;\Longrightarrow\;\; 1-3\alpha \lt 0 \;\;\Longrightarrow\;\; \alpha \gt \frac{1}{3}. \]

Any \( \alpha \gt 1/3 \) makes the stabilizing feedback dominate the open-loop instability. With bounded \( u_H \), the system is ISS as shown in Theorem 4.1.

Problem 3 (Intelligence improvement bound): A baseline policy \( \pi_0 \) has cost \( J(\pi_0)=120 \). A new policy \( \pi \) yields \( J(\pi)=90 \). Compute \( \mathcal{I}(\pi;\pi_0) \). Prove that if \( J(\pi)\ge 0 \), then \( \mathcal{I}(\pi;\pi_0)\le 1 \).

Solution:

\[ \mathcal{I}(\pi;\pi_0)=1-\frac{90}{120}=1-0.75=0.25. \]

So intelligence improved by 25% relative to baseline.

Proof of upper bound. If \( J(\pi)\ge 0 \) and \( J(\pi_0)\gt 0 \), then \( \frac{J(\pi)}{J(\pi_0)}\ge 0 \), hence

\[ \mathcal{I}(\pi;\pi_0)=1-\frac{J(\pi)}{J(\pi_0)} \le 1. \]

Equality occurs only for \( J(\pi)=0 \), i.e., a perfect policy under the chosen cost. □

We defined autonomy as the fraction of control/decisions generated internally by the robot, and intelligence as performance plus adaptivity under uncertainty. Shared autonomy was modeled as a convex blend between human and autonomous commands, and we proved input-to-state stability when the autonomous controller is stabilizing and contributes nontrivially. Minimal multi-language examples illustrated how the autonomy factor shapes behavior.