The Math Trick That Could Make Self-Driving Cars React Faster in Emergencies

Somewhere between the moment a child runs into the road and the moment an autonomous vehicle must decide whether to swerve, there is a window of perhaps 200 milliseconds. In that window, a controller — a mathematical algorithm running on a processor — has to compute what the steering and throttle should do next. The problem is that the mathematics governing a real vehicle are messy, nonlinear, and coupled in ways that make computing the "right" answer expensive. Most principled approaches to safety require solving an optimization problem in that window. And optimization takes time.

A new paper from Aadila Ali Sabry and Gennaro Notomista at the University of Waterloo proposes a way out of this tension (Sabry & Notomista, 2026). By combining two powerful ideas — differential flatness and the Newton-Raphson tracking controller — they show that a large class of robotic systems, including autonomous vehicles, can be controlled with formally proven safety guarantees using nothing more than algebra. No iterative solver. No per-step optimization. Just a closed-form formula evaluated at each time step.

The result is a controller that is both provably correct and computationally cheap. That combination, if it holds up in hardware, could matter enormously for the next generation of self-driving cars.

The Science

The paper lives at the intersection of two research threads, and it's worth understanding each one before seeing how they connect.

The first is the Newton-Raphson (NR) tracking controller, introduced in prior work by one of the paper's co-authors. The NR controller is inspired by Newton-Raphson root-finding — the iterative method you may have seen used to solve equations numerically. The idea is to treat control as a root-finding problem: at every moment, you want the future predicted output of your system to equal the desired reference signal. You then adjust the control input continuously to drive the error toward zero. The result is a dynamical equation for the control input $\dot{u}(t)$, rather than a static formula, and it has been shown to work on autonomous vehicles, flying robots, and multi-robot teams (Sabry & Notomista, 2026).

The NR controller comes with a notion of stability called $\alpha$-stability. The $\alpha$ here is a "speedup factor" — a scalar greater than one that appears in the control law. Intuitively, \alpha$-stability means that as you crank $\alpha up toward infinity, the system's tracking error vanishes. More precisely, a system is $\alpha$-stable if the magnitude of the full state trajectory is bounded by a function of the reference signal's magnitude plus a function of the initial conditions — no matter how the reference wiggles around within a defined set. This is a strong guarantee: it means the controller won't blow up, and it will eventually follow the target. The challenge has been that prior work only proved $\alpha$-stability for linear systems. The new paper extends this to the much larger class of differentially flat nonlinear systems.

The second key ingredient is differential flatness. A dynamical system is differentially flat if there exists a special set of outputs — called flat outputs — such that every state and input of the system can be written as an algebraic function of those outputs and their derivatives. Think of it as a change of variables that untangles the system's complexity. The dynamics of a car look complicated in terms of position, velocity, heading, and steering angle. But in terms of carefully chosen flat outputs, the same car is equivalent to a handful of independent integrators — the simplest possible dynamical system. The mapping between the two descriptions is called an endogenous transformation, and it goes both ways: you can move freely between the messy real dynamics and the clean flat-output space.

The block diagram above captures the core idea. You take the complicated real system, transform it into the flat output space (step 1), apply the NR controller there (step 2), then map the resulting control action back to the real system (step 3). The entire computation is algebraic. The inverse endogenous transformation — the map from flat-output space back to real inputs — is just a formula you evaluate, not a problem you solve.

The key question the paper answers is: does controlling the flat-output system with the NR controller actually guarantee $\alpha$-stability? And under what conditions is this equivalent to applying the NR controller directly to the original nonlinear dynamics?

What They Found

The paper's central result is a surprisingly clean sufficient condition for \alpha$-stability (Sabry & Notomista, 2026). The flat output dynamics are always linear — they look like a chain of integrators — and the NR controller applied to a linear system produces a characteristic polynomial $P_\alpha(s) that determines stability. The authors compute this polynomial explicitly:

$$P_{\alpha }(s)={\left(s^{k+2}+\alpha \frac{(k+1)!}{T^{k+1}}\sum _{i=0}^{k+1}\frac{T^i}{i!}{s}^i\right)}^m$$

Here $k$ is the order of the flat output (how many derivatives appear before the control input shows up), $T$ is the prediction horizon, $m$ is the number of inputs, and $\alpha$ is the speedup factor. For \alpha$-stability, you need the two auxiliary polynomials $P_0(s) and $Q(s)$ to have all their roots in the open left half-plane — the standard condition for a stable linear system.

The punchline is elegant. $Q(s)=(s+1{)}^m$ by the binomial theorem, and it always has roots at $s=-1$ — safely in the left half-plane, for any system. $P_0(s)$ is a finite Maclaurin (Taylor) series approximation of $e^{Ts}$, and it has all roots in the left half-plane if and only if $k\le 3$. That's it. If the flat output order is at most 3 — meaning the control input appears no later than the fourth derivative — the system is $\alpha$-stable.

α-stability condition: flat output order k vs. stability

Label	Value
k = 0	1
k = 1	1
k = 2	1
k = 3	1
k = 4	0
k = 5	0

Source: Sabry & Notomista (2026), Section III-A. Stability determined by roots of the finite Maclaurin expansion of e^(Ts).

This is a remarkable compression of complexity. Autonomous vehicle models, wheeled robots, and many aerial vehicles all have flat outputs of order 1 or 2. The condition $k\le 3$ is almost always satisfied in practice. What was previously a difficult, case-by-case stability analysis collapses to checking a single integer.

The paper also proves convergence for a modified version of the controller. By adding a correction term that accounts for how the predicted output changes with the flat state, the authors obtain a controller whose Lyapunov function $V(t)=\frac{1}{2}\Vert e(t+T){\Vert }^2$ satisfies $\dot{V}(t)=-2\alpha V(t)$ when the reference is constant. That's exponential stability — the error decays at rate $e^{-2\alpha t}$, and you can make it decay as fast as you like by increasing $\alpha$.

The third main result characterizes when the flat-space controller is equivalent to applying the NR controller directly to the nonlinear dynamics. This equivalence holds under four conditions that the authors show are easily verifiable: the endogenous transformation doesn't depend on derivatives of $\nu$ (the flat-space input), the flat output doesn't depend on derivatives of $u$, the real state $x$ doesn't depend on $\nu$, and the Jacobian of the transformation has full rank. These are not exotic requirements. Both the kinematic unicycle and the dynamic bicycle model satisfy all four.

Flat output order k for common robotic systems

Label	Value
Kinematic unicycle	1
Dynamic bicycle	1

Source: Sabry & Notomista (2026), Section IV. Kinematic unicycle and dynamic bicycle both satisfy the α-stability condition.

Why This Changes Things

To appreciate what's at stake, it helps to understand the landscape of competing approaches. Model predictive control (MPC) is the dominant workhorse for constrained trajectory tracking. It works by solving an optimization problem at every time step — minimizing a cost function subject to dynamics and safety constraints over a rolling horizon. MPC can handle complex constraints beautifully, but it is computationally demanding. Even with successive linearizations, the per-step cost can be prohibitive for fast dynamics or resource-constrained hardware.

The NR controller trades some of MPC's flexibility for a dramatic reduction in computational cost. There is no optimization problem to solve. The control input at each step comes from evaluating a formula — multiplying matrices, inverting a Jacobian, computing a prediction. On modern hardware, this takes microseconds, not milliseconds. And now, for differentially flat systems, it comes with the same kind of stability guarantee that makes MPC attractive in the first place.

This matters most in what the paper calls "safety-critical scenarios where controllers need to respond in a timely fashion to mitigate collision or realize evasive maneuvers." An autonomous vehicle executing an emergency swerve has perhaps 100–300 milliseconds to respond before the situation becomes unrecoverable. A controller that requires solving a quadratic program — even a small one — may not fit in that window on embedded hardware. A controller that just evaluates a closed-form expression almost certainly does.

The dynamic bicycle model (shown above) is the paper's most practically relevant test case. It models a vehicle by tracking the position and heading of the rear axle, with acceleration and steering rate as inputs. This is a standard reduced-order model used in autonomous driving research. The flat outputs are the rear-axle coordinates $(p_x,p_y)$, and the paper shows that the full NR controller framework applies with $k=1$ — well within the $k\le 3$ guarantee. Simulations confirm that the controller tracks reference trajectories accurately, with the flat-space and direct nonlinear controllers producing equivalent behavior.

The kinematic unicycle model, a simpler system often used as a testbed in mobile robotics, is analyzed first for illustration.

It has inputs $v$ (longitudinal velocity) and $\omega$ (angular velocity), and its flat output is also the wheel-center position. The controller successfully tracks a sinusoidal reference, with the computed control inputs shown in

.

What unifies both examples is the structure of the proof: differential flatness does the heavy lifting of transforming a nonlinear problem into a linear one, and the NR controller's $\alpha$-stability machinery then applies cleanly. The result is a framework general enough to cover a wide family of systems, not just the specific models the authors tested.

Controller comparison: NR vs. MPC on key properties

Label	Value
Computational speed	5
Formal stability guarantees	4
Handles constraints	2
Closed-form solution	5
Nonlinear systems	4

Qualitative summary based on paper claims (Sabry & Notomista, 2026) and standard MPC literature. Not a quantitative benchmark.

What's Next

The paper is careful about what it has and hasn't proven. The convergence proof for the modified controller requires the reference to be constant — a significant restriction. Real driving involves continuously changing references: lane changes, speed adjustments, curved roads. The authors report that simulations with dynamic references converge in practice, but a formal proof for time-varying references remains open. Bridging that gap is the most pressing theoretical task ahead.

There are also practical questions about robustness. The NR controller's closed-form expression involves inverting the Jacobian $\frac{\partial g}{\partial \nu }$. If that Jacobian becomes ill-conditioned — near certain configurations of the vehicle — the control input could become large or erratic. Prior work has shown robustness to perturbations in this Jacobian for a generalized version of the controller, and the authors note this applies here as well. But quantifying how much perturbation is tolerable, and designing the system to stay away from singular configurations, are engineering challenges that remain.

The restriction to differentially flat systems is also a real constraint. Many important systems — including those with dry friction, certain fluid-structure interactions, and some classes of underactuated robots — are not flat. Extensions to nearly-flat or approximately-flat systems, perhaps using flatness as a local approximation, would significantly broaden the framework's reach.

Still, the class of differentially flat systems is larger than it might appear. Wheeled robots of almost every configuration, quadrotors, fixed-wing aircraft, surface vessels, robotic manipulators — all are flat. The autonomous vehicle application alone encompasses hundreds of millions of vehicles potentially. If the framework transitions from simulation to hardware, the computational savings could be substantial: less processing power per vehicle means less energy consumption, longer battery life in electric vehicles, and feasibility on cheaper embedded platforms.

The deeper significance of the paper is not just the specific result, but what it demonstrates about the geometry of control. Differential flatness is a statement about the shape of a system — that its trajectories live in a simpler space than they appear to. The $k\le 3$ condition is a statement about how that simplicity interacts with the prediction horizon. Together, they show that a large swath of real-world dynamics can be tamed not by brute-force computation, but by choosing the right coordinates. The most elegant solutions in control theory have always worked this way: find the frame in which the problem looks easy, then solve it there. Sabry and Notomista have found such a frame for autonomous vehicles, and proven it works.