Constructing The Real Numbers With Cauchy Sequences

This is a sample post, meant to show what a mathematical essay feels like on the site. The central idea is simple: motion is not only a change in position, but a change in what a system can do next.

A state, and a rule

Suppose a machine has a state $x_t$ at time $t$. A controller observes that state and chooses an action $u_t$. The machine then moves according to some rule

$$ x_{t+1} = f(x_t, u_t). $$

The notation is compact, but it hides a useful distinction. The function $f$ describes what the world does. A policy $pi$ describes what the machine decides to do:

$$ u_t = \pi(x_t). $$

Example. Consider a small vehicle moving through a room. Its state might include its position $p$, velocity $v$, and heading $\theta$. A useful state vector is therefore

$$ x = (p_x, p_y, v_x, v_y, \theta). $$

This is not the vehicle itself. It is a working description of the vehicle: a collection of quantities that are relevant to the next decision. If the controller only needs to avoid walls, it may not need to remember the color of the floor.

In the example above, we say that $x$ is an internal state of the machine. In general, a state is useful when it contains the information needed to predict what can happen next. For a more formal treatment, see this short introduction to state-space models.

Aside. We could also turn the question on its head. Suppose we are given a desired motion and a machine with limited control. Can we find a sequence of actions that produces the motion? This time, the answer is not always yes. But when it is, we say the motion is reachable. The distinction between what a system can observe and what it can reach will matter later.

A tower of descriptions

One way to understand a complicated machine is to build its description in layers. We begin with a coarse state, then add detail only when the next question requires it:

$$ X_0 \subseteq X_1 \subseteq X_2 \subseteq \cdots \subseteq X_m = X. $$

Here $X_i$ is a progressively richer description of the same underlying system. The structure of this tower matters: a good abstraction should preserve the distinctions that the controller needs, while allowing everything else to remain invisible.

The point is not to construct the largest possible model. It is to construct the smallest useful world in which the machine can make its next decision.

Together, these give us a closed loop:

$$ x_{t+1} = f\bigl(x_t, \pi(x_t)\bigr). $$

The point of the loop is not that the machine has a perfect model. It is that every action changes the state from which the next action will be chosen.

Why feedback matters

Without feedback, a machine follows a plan as if the world were still the world in which the plan was written. With feedback, it can notice that the world has moved.

In a noisy setting, the observation is better written as

$$ y_t = h(x_t) + \varepsilon_t, $$

where $h$ is the observation function and $\varepsilon_t$ is error. A useful controller therefore has to answer two questions at once:

1. What state is the machine probably in?
2. Which action makes the next state more useful?

This is already a small theory of agency. The machine does not need to “understand” the world in the human sense. It needs a representation that is good enough to support the next decision.

A question to keep

The interesting question is not whether a machine can move. We know that it can. The question is what kind of internal structure lets motion become purposeful rather than merely reactive.

That question will return throughout this site.