Informally, a robot is “a machine that can perceive its environment, decide, and act to achieve goals.” To make this precise, we need three ingredients:

• Embodiment: the system has a physical body that can affect the world.
• Perception: the system acquires information through sensors.
• Action: the system applies forces/torques through actuators.

A key differentiator from simple automation is closed-loop interaction: the robot’s future actions depend on sensed outcomes of past actions.

flowchart TD
  E["Environment"] -->|sensed signals| S["Sensors"]
  S --> P["Perception / State Estimation"]
  P --> C["Computation / Controller"]
  C --> A["Actuators"]
  A -->|forces / motion| E
        

Let the environment be described by a state \( x_e(t) \in \mathbb{R}^{n_e} \), and the robot’s internal (body + electronics) state by \( x_r(t) \in \mathbb{R}^{n_r} \). Define the combined closed-loop state \( x(t) := \begin{bmatrix} x_r(t) \\ x_e(t) \end{bmatrix} \).

A robot must (i) sense the environment, (ii) compute decisions, and (iii) act physically. We model these as:

2.1 Sensing (measurement map). Sensors generate measurements

\[ y(t) = h(x_r(t), x_e(t)) + \eta(t), \quad y(t)\in\mathbb{R}^{m}, \]

where \( h \) is the sensor function and \( \eta(t) \) is measurement noise.

2.2 Actuation (control input). Actuators create a control input

\[ u(t) \in \mathbb{R}^{p}, \]

interpreted as inputs to motors, valves, or other effectors that physically influence \( x_r \) and often \( x_e \).

2.3 Body–environment dynamics. The closed-loop physical evolution is

\[ \dot{x}(t) = f(x(t),u(t)) = \begin{bmatrix} f_r(x_r(t),x_e(t),u(t)) \\ f_e(x_e(t),x_r(t),u(t)) \end{bmatrix}. \]

2.4 Computation / policy. A robot’s “brain” implements a policy

\[ u(t) = \pi\!\big( y_{0:t},\, r_{0:t} \big), \]

where \( y_{0:t} \) denotes the measurement history and \( r_{0:t} \) possible reference commands (from a human or a planner). The dependence on history captures internal memory.

Definition (Robot as a closed-loop embodied agent). A system is a robot if there exists a nontrivial policy \( \pi \) such that the closed-loop dynamics \( \dot{x}(t)=f(x(t),\pi(y_{0:t},r_{0:t})) \) produce physical actions that (a) depend on sensed interaction with the environment and (b) are modifiable by reprogramming \( \pi \).

3.1 Embodiment. The robot must be able to exert a physical influence:

\[ \frac{\partial f_e}{\partial u} \neq 0 \quad \text{for some operating region.} \]

If \( \partial f_e/\partial u = 0 \) everywhere, the system cannot affect the environment, so it is not a robot (it may be a sensor network).

3.2 Sensing and observability of interaction. The environment must influence measurements:

\[ \frac{\partial h}{\partial x_e} \neq 0. \]

This is the perception analogue of coupling: without it, the robot cannot condition actions on the world.

3.3 Closed-loop adaptivity. Actions must depend on sensing:

\[ \frac{\delta u(t)}{\delta y(\tau)} \neq 0 \quad \text{for some } \tau \le t. \]

This functional derivative means the policy reacts to measurements. Open-loop automation has \( \delta u / \delta y = 0 \).

3.4 Autonomy (degree, not a binary property). Suppose a robot blends external command \( r(t) \) with internal decision \( \phi(y_{0:t}) \):

\[ u(t)=\alpha\, r(t) + (1-\alpha)\,\phi(y_{0:t}), \quad 0 \le \alpha \le 1. \]

Then \( 1-\alpha \) is a simple autonomy index: fully teleoperated systems have \( \alpha=1 \), fully autonomous systems (no external command) have \( \alpha=0 \).

3.5 Reprogrammability. Let \( \Pi \) be the set of implementable policies on the robot hardware. A robot is reprogrammable if \( |\Pi| > 1 \).

A washing machine has essentially one fixed policy (\( |\Pi|=1 \)), so it is automation, not a robot.

flowchart TD
  R["Robot?"] --> E1["Embodied? d f_e / d u != 0"]
  E1 -->|yes| S1["Senses world? d h / d x_e != 0"]
  S1 -->|yes| CL["Closed-loop? d u / d y != 0"]
  CL -->|yes| P1["Reprogrammable? |Pi| > 1"]
  P1 -->|yes| ROB["Robot (degree of autonomy varies)"]
  E1 -->|no| NA1["Not a robot"]
  S1 -->|no| NA2["Not a robot"]
  CL -->|no| NA3["Automation or mechatronic device"]
  P1 -->|no| NA4["Fixed-function automation"]
        

We formalize a crisp statement that separates robots from purely open-loop machines.

Proposition. If a system is a robot under the definition of Section 2, then its policy must be measurement-coupled: \( \exists\, t,\tau \text{ with } \tau \le t \text{ such that } \delta u(t)/\delta y(\tau) \neq 0 \).

Proof.

Assume for contradiction that \( \delta u(t)/\delta y(\tau)=0 \) for all \( \tau \le t \). Then \( u(t)=\pi(r_{0:t}) \) is independent of measurements. Substituting into the physical dynamics yields \( \dot{x}(t)=f(x(t),\pi(r_{0:t})) \), which is an open-loop system whose actions cannot adapt to environmental outcomes. This violates the requirement in Section 2 that action depends on sensed interaction. Hence the assumption is false, so the policy must be measurement-coupled. \(\square\)

This result is simple but foundational: it guarantees that robotics is intrinsically a feedback discipline even before we study kinematics.

This lesson is mostly conceptual, but a tiny “sense–compute–act” loop can make the definition concrete. The code below intentionally avoids advanced robotics math reserved for later chapters.

5.1 Python (NumPy + simple policy)

import numpy as np

class MinimalRobot:
    """
    Minimal embodied agent:
    x_r: robot internal state (here 1D position)
    x_e: environment state (here a target position)
    y  : measurement of environment relative position
    u  : actuator command (velocity)
    """
    def __init__(self, x_r0=0.0):
        self.x_r = float(x_r0)

    def sense(self, x_e):
        # measurement map y = h(x_r, x_e)
        return x_e - self.x_r

    def policy(self, y, alpha=0.0, r=0.0):
        # u(t) = alpha * r(t) + (1-alpha) * phi(y)
        phi = 0.5 * y              # simple reactive rule
        return alpha * r + (1-alpha) * phi

    def actuate(self, u, dt=0.1):
        # body dynamics: x_r_dot = u
        self.x_r += u * dt

# simulate closed-loop coupling
robot = MinimalRobot(x_r0=0.0)
x_e = 10.0  # "environment": target position

for t in range(50):
    y = robot.sense(x_e)
    u = robot.policy(y, alpha=0.2, r=0.0)  # partially autonomous
    robot.actuate(u)
print("Final robot position:", robot.x_r)
      

Note the measurement coupling: changing \( y \) changes \( u \) immediately. You can verify that setting phi = constant makes it open-loop.

5.2 C++ (Eigen for vectors; ROS2-ready structure)

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

struct MinimalRobot {
    double x_r; // 1D internal state
    explicit MinimalRobot(double x0=0.0) : x_r(x0) {}

    double sense(double x_e) const {
        return x_e - x_r; // y = h(x_r, x_e)
    }

    double policy(double y, double alpha=0.0, double r=0.0) const {
        double phi = 0.5 * y;
        return alpha * r + (1.0 - alpha) * phi; // u(t)
    }

    void actuate(double u, double dt=0.1) {
        x_r += u * dt; // x_r_dot = u
    }
};

int main() {
    MinimalRobot robot(0.0);
    double x_e = 10.0;

    for(int k=0; k<50; ++k){
        double y = robot.sense(x_e);
        double u = robot.policy(y, 0.2, 0.0);
        robot.actuate(u);
    }
    std::cout << "Final robot position: " << robot.x_r << std::endl;
    return 0;
}
      

Typical C++ robotics libraries you will meet later: ROS2 (rclcpp), Eigen, Orocos KDL, and Pinocchio.

5.3 Java (EJML for linear algebra; minimal loop)

public class MinimalRobot {
    private double x_r;

    public MinimalRobot(double x0){
        this.x_r = x0;
    }

    public double sense(double x_e){
        return x_e - x_r;
    }

    public double policy(double y, double alpha, double r){
        double phi = 0.5 * y;
        return alpha * r + (1.0 - alpha) * phi;
    }

    public void actuate(double u, double dt){
        x_r += u * dt;
    }

    public static void main(String[] args){
        MinimalRobot robot = new MinimalRobot(0.0);
        double x_e = 10.0;

        for(int k=0; k<50; k++){
            double y = robot.sense(x_e);
            double u = robot.policy(y, 0.2, 0.0);
            robot.actuate(u, 0.1);
        }
        System.out.println("Final robot position: " + robot.x_r);
    }
}
      

Java robotics ecosystems include ROS2 Java bindings and linear algebra packages such as EJML.

5.4 MATLAB / Simulink (Robotics System Toolbox)

% MinimalRobot in MATLAB
x_r = 0;         % robot state
x_e = 10;        % environment target
dt  = 0.1;
alpha = 0.2;

for k = 1:50
    y = x_e - x_r;           % sensing: y = h(x_r, x_e)
    phi = 0.5 * y;           % internal reactive rule
    u = alpha*0 + (1-alpha)*phi;  % blended autonomy
    x_r = x_r + u*dt;        % actuation/body dynamics
end
disp(x_r)

% Simulink idea:
% Use blocks: Sum (x_e - x_r) -> Gain (0.5) -> Blend -> Integrator (x_r_dot=u)
      

Later chapters will connect these loops to detailed kinematics and dynamics.

Problem 1 (Coupling Test): Consider a machine with dynamics \( \dot{x}_r = f_r(x_r,u) \) and measurement \( y=h(x_r) \). Suppose the control law is \( u(t)=u_0(t) \) (pre-programmed, no sensing). Show that it fails the necessary condition for being a robot.

Solution:

Since \( u(t) \) is independent of measurements, \( \delta u(t)/\delta y(\tau)=0 \) for all \( \tau \le t \). By Proposition in Section 4, measurement coupling is necessary; therefore the machine is open-loop automation, not a robot. \(\square\)

Problem 2 (Embodiment Criterion): A “smart thermostat” measures room temperature \( y=T \) and computes a signal \( u \) to switch a heater. The room dynamics are

\[ \dot{T}(t) = -k(T(t)-T_{out}) + b\,u(t). \]

Does \( \partial f_e/\partial u \neq 0 \) hold? Is this a robot under our definition?

Solution:

Here \( x_e=T \) and \( f_e(T,u)=-k(T-T_{out})+b\,u \). Since \( \partial f_e/\partial u=b \neq 0 \), the system is embodied (it affects the environment temperature). However, reprogrammability is typically limited: many thermostats implement essentially one fixed policy. If \( |\Pi|=1 \), it is fixed-function automation. If the policy can be changed (e.g., software-updated schedules, adaptive regulation), then it satisfies all conditions and can be viewed as a simple robot. The classification hinges on \( |\Pi| \).

Problem 3 (Autonomy Index): A mobile platform is driven by a human joystick command \( r(t) \) but also has obstacle avoidance \( \phi(y_{0:t}) \). The blended command is \( u(t)=0.7 r(t)+0.3\phi(y_{0:t}) \). Compute the autonomy index and interpret it.

Solution:

Comparing with \( u(t)=\alpha r(t)+(1-\alpha)\phi(y_{0:t}) \), we have \( \alpha=0.7 \) and autonomy index \( 1-\alpha=0.3 \). So the system is mostly teleoperated but has meaningful local autonomy for safety (30% internal authority).

Problem 4 (Design a Minimal Robot Model): Provide a minimal continuous-time state-space model \( \dot{x}=Ax+Bu \), measurement \( y=Cx \), and feedback policy \( u=-Ky \) that satisfies all robot conditions.

Solution:

Choose any controllable-and-observable triple \( (A,B,C) \) with \( B \neq 0 \) and \( C \neq 0 \). For instance,

\[ A=\begin{bmatrix}0 & 1\\0 & 0\end{bmatrix},\quad B=\begin{bmatrix}0\\1\end{bmatrix},\quad C=\begin{bmatrix}1 & 0\end{bmatrix}. \]

Then \( \partial f_e/\partial u \neq 0 \) because \( B \) is nonzero, sensing depends on state because \( C \neq 0 \), and closed-loop coupling holds since \( u=-KCx \) explicitly depends on measurements. Multiple choices of \( K \) give \( |\Pi|>1 \), so it is reprogrammable. Hence it qualifies as a robot.

We defined a robot rigorously as an embodied cyber–physical agent with sensing, computation, and actuation in a closed loop. Key mathematical signatures are environment coupling \( \partial f_e/\partial u \neq 0 \), perceptual coupling \( \partial h/\partial x_e \neq 0 \), feedback coupling \( \delta u/\delta y \neq 0 \), and reprogrammability \( |\Pi|>1 \). These ideas ground the distinctions we will sharpen in Lesson 2 between robots, automation, and mechatronic systems.