🔢 mathematics

Time-optimal neural feedback control of nilpotent systems as a binary classification problem

This paper proposes a computational framework for synthesizing time-optimal feedback control laws for linear nilpotent systems by first using algebraic methods to exhaustively solve for optimal switching sequences and then training a deep neural network, interpreted as a binary classifier, on the resulting dataset to achieve accurate and robust real-time control.

Original authors: Sara Bicego, Samuel Gue, Dante Kalise, Nelly Villamizar

Published 2026-05-20

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Sara Bicego, Samuel Gue, Dante Kalise, Nelly Villamizar

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are driving a car that can only go full speed forward or full speed backward, and you need to stop exactly at a specific spot (the origin) in the shortest time possible. This is the core challenge of time-optimal control. The paper tackles this problem for a specific type of vehicle (mathematically called a "nilpotent system," which acts like a chain of connected integrators, similar to how a car's position, speed, and acceleration are linked).

Here is how the authors solve this puzzle, explained through simple analogies:

1. The Puzzle: Finding the Perfect Switching Times

In an ideal world, if you knew exactly where you started, you could calculate the exact moments to switch from "full forward" to "full backward" to stop perfectly.

The Old Way: Previous methods tried to solve this using complex algebraic tools (like Gröbner bases). Think of this like trying to solve a massive jigsaw puzzle by checking every single piece against every other piece. It works for small puzzles (simple systems), but as the puzzle gets bigger (higher dimensions), it takes forever and becomes impossible to do in real-time.
The New Way: The authors propose a smarter strategy. They turn the problem into a set of mathematical equations (polynomials) where the unknowns are the times you should switch.

2. The Engine: A "Deflated" Search

To solve these equations, they use a technique called Newton's method, which is like a hiker trying to find the bottom of a valley.

The Problem: Sometimes, a hiker finds a small dip (a solution) but misses the real bottom, or gets stuck in a loop. Also, there might be many valleys, and you need to find all of them to be sure you have the best one.
The Solution (Deflation): The authors use a "deflated" Newton method. Imagine that every time the hiker finds a valley, they magically fill it with concrete so it can't be found again. Then, they look for the next lowest valley. This ensures they find every possible solution without getting stuck on the same one twice.

3. The Map: Knowing How Many Valleys Exist

A major risk in this "filling valleys" game is not knowing when to stop. How do you know you've found all the valleys?

The Tool (Hermite Quadratic Form): The authors use a mathematical tool called the Hermite quadratic form. Think of this as a magic map that tells you exactly how many valleys exist in the landscape before you even start walking.
Why it matters: If the map says there are 3 valleys, the computer knows to stop searching after finding 3. This prevents the computer from wasting time or crashing because it's looking for a 4th valley that doesn't exist. This makes the process fast and reliable enough for real-time use.

4. The Brain: Training a Neural Network as a Binary Classifier

Solving these equations every time you need to steer is still too slow for a real-time controller (like a drone or robot). So, the authors do something clever: they teach a computer to guess the answer.

The Dataset: They run the "perfect" mathematical solver thousands of times on different starting points. They record the starting position and the correct first move (Forward or Backward).
The Teacher: They treat this like a binary classification problem. Instead of asking the computer to predict a number, they ask it a simple Yes/No question: "Should I go +1 (forward) or -1 (backward)?"
The Student (Neural Network): They train a deep neural network (a type of AI) on this data. The network learns the complex "switching surface"—the invisible line in space that tells you when to flip your switch.
Confidence Meter: The AI doesn't just guess; it gives a confidence score. If it's 99% sure, it acts immediately. If it's unsure (like right on the edge of the switching line), it can call the "perfect solver" for a quick second opinion.

5. The Results: Fast, Robust, and Accurate

The authors tested this on systems with 2, 3, 4, and 5 dimensions (like a car with just position, or a car with position, speed, acceleration, etc.).

Accuracy: The AI learned to make the right choice over 99% of the time.
Robustness: When they added "noise" (simulating wind or sensor errors), the AI-controlled system kept steering itself back to the target. The old "open-loop" method (just calculating the path once and hoping for the best) crashed or missed the target.
Speed: The AI makes decisions instantly, whereas the old math-heavy methods would take too long to calculate the path while the vehicle was moving.

Summary

The paper presents a two-step recipe for controlling complex machines as fast as possible:

Math: Use a smart search algorithm (Deflated Newton) guided by a "valley counter" (Hermite form) to generate perfect training data.
AI: Train a neural network to act as a binary classifier that instantly decides whether to go forward or backward based on where the machine is.

This approach bridges the gap between heavy mathematical theory and the need for fast, real-time decision-making in robotics and aerospace.

Technical Summary: Time-Optimal Neural Feedback Control of Nilpotent Systems as a Binary Classification Problem

1. Problem Statement

The paper addresses the synthesis of time-optimal feedback control laws for linear nilpotent systems, specifically chains of integrators. The objective is to steer a system $\dot{y}(t) = Ay(t) + bu(t)$ from an initial state $x$ to the origin in minimum time $T$ , subject to the control constraint $u(t) \in [-1, 1]$ .

According to the classical bang-bang theorem, the optimal control signal for such systems is piecewise constant, taking values in $\{-1, 1\}$ with at most $n-1$ switches (where $n$ is the system dimension). While the open-loop solution for a specific initial condition can be characterized by a polynomial system governing the switching times, constructing a real-time feedback law (a map from state $x$ to control $u$ ) is computationally challenging. Traditional methods involving Gröbner bases or solving Hamilton-Jacobi-Bellman PDEs suffer from prohibitive computational complexity in higher dimensions or require grid-based discretization that limits scalability.

2. Methodology

The proposed approach combines numerical algebraic geometry, root-finding algorithms, and supervised machine learning to construct an approximate feedback controller. The methodology is divided into two main phases:

Phase I: Synthetic Data Generation via Deflated Newton's Method

To generate the dataset required for training, the authors solve the time-optimal control problem for various initial conditions.

Polynomial Formulation: The time-optimal control problem is reformulated as a system of polynomial equations (Equation 2.5) in terms of the switching time increments $\{t_i\}$ . The existence of a non-negative solution to this system determines the optimal switching sequence for a given initial control value $u(0) \in \{-1, 1\}$ .
Root Finding: Instead of using Gröbner bases (which are noted to have double-exponential complexity), the authors employ a deflated Newton's method. This iterative technique systematically alters the residual of the polynomial system to "deflate" known roots, allowing the algorithm to exhaust all possible real roots of the system.
Root Counting via Hermite Quadratic Forms: A critical component of the deflation strategy is determining the stopping criterion (i.e., how many roots to expect). The authors utilize the Hermite quadratic form to compute the exact number of real roots for the polynomial system given a specific initial condition. This provides a sharp bound ( $n_{roots}$ ) for the deflation algorithm, preventing numerical instability and ensuring all solutions are found without unnecessary iterations.
Dataset Construction: For each sampled initial condition, the system solves the polynomial system for both $u(0)=1$ and $u(0)=-1$ . The valid non-negative solution identifies the optimal switching structure. The authors then sample 100 points along the resulting optimal trajectory to create a dataset of state-control pairs $(y, u)$ .

Phase II: Neural Feedback as a Binary Classifier

The second phase interprets the time-optimal feedback law as a binary classification problem.

Classification Framework: Since the optimal control $u(t)$ takes values in $\{-1, 1\}$ , the feedback map is modeled as a classifier mapping the state space $\mathbb{R}^n$ to $\{-1, 1\}$ .
Neural Network Architecture: A deep feedforward neural network is trained using the synthetic dataset generated in Phase I. The final layer uses a sigmoid activation function to output a probability $P(u=1)$ , allowing the model to provide a confidence measure for its classification.
Hybrid Control Strategy: To address the difficulty of classifying states near the switching surface (where confidence is low), the authors propose a hybrid approach. If the neural network's confidence falls below a threshold $\epsilon$ , the system invokes the open-loop polynomial solver (Phase I) to determine the precise control action for that specific state.

3. Key Contributions

Computational Workflow for Nilpotent Systems: The paper proposes a consistent workflow that circumvents the limitations of Gröbner bases for higher-dimensional systems by combining deflated Newton methods with Hermite quadratic forms for root counting.
Root Counting via Hermite Forms: The application of Hermite quadratic forms to determine the number of real roots in time-optimal polynomial systems is highlighted as a mechanism to ensure the efficiency and stability of the root-finding procedure.
Binary Classification Formulation: The authors reframe the synthesis of time-optimal feedback laws as a supervised learning binary classification task. This approach bypasses the need for iterative recomputation of trajectories during real-time operation.
Confidence-Enhanced Feedback: The integration of a confidence threshold allows for a hybrid control law that leverages the speed of neural network inference for most states while falling back to the exact polynomial solver for ambiguous states near switching surfaces.

4. Numerical Results

The methodology was tested on integrator chains of dimensions $n=2$ through $n=5$ .

Accuracy: The neural network classifiers achieved high test set accuracy, ranging from 96.76% (4th-order) to 99.61% (5th-order).
Robustness: Monte Carlo simulations with additive Gaussian noise demonstrated that the neural feedback law successfully drives the system to the origin, whereas open-loop solutions diverged due to the lack of feedback correction.
Performance of Hybrid Strategy:
- In the 2nd-order case, the hybrid strategy (invoking the solver for low-confidence points) showed negligible improvement over the pure neural controller, as the network classified switching surface points correctly even with low confidence.
- In higher dimensions (3rd, 4th, and 5th order), the hybrid approach significantly improved the approximation of the optimal time horizon ( $T_{NN}$ ), reducing the time to reach the origin compared to using the neural network alone.
Computational Efficiency: The use of Hermite quadratic forms to bound the number of roots reduced the CPU time for data generation in the 4th-order case from 108 minutes (using theoretical bounds) to 49 minutes.

5. Significance and Claims

The paper claims to offer a scalable alternative to algebraic geometry-based methods (like Gröbner bases) for constructing real-time feedback controllers for nilpotent systems. The authors explicitly state that while Gröbner bases are theoretically sound, their computational cost renders them inapplicable for state spaces with dimension greater than 3.

The significance of the work lies in:

Scalability: Demonstrating that time-optimal control synthesis can be extended to dimensions up to 5 using the proposed numerical and learning-based approach.
Real-Time Feasibility: Replacing the iterative solution of polynomial systems at runtime with a single forward pass of a neural network, augmented by a fallback mechanism only when necessary.
Handling Non-Smoothness: Successfully approximating the discontinuous bang-bang control law (a non-smooth field) by treating it as a classification problem, a task where traditional global approximation techniques often struggle.

The authors remain modest regarding the scope, noting that the Hermite quadratic form computation itself becomes computationally expensive as dimension increases (successfully computed up to dimension 7, but used for data generation up to 5 in the experiments). They suggest that the interpolation of bang-bang laws via binary classification opens avenues for other sparse control problems with similar structures.