Formal Abstractions for Continuous and Stochastic Control Systems

This direction is split into other directions: symbolic abstraction (state-space discretization). Its last version stays readable and citable here.

Version 1 of 162 papers68 conceptsfrozen 2026-10-04

The physical world is continuous, defined by infinite states and smooth trajectories. However, the algorithms we use to control this world—the logic inside a drone’s flight controller or a power grid’s stabilizer—are discrete. This creates a fundamental "impedance mismatch": how can a finite computer program provide mathematical guarantees about an infinite-state physical system?

The research direction of formal abstractions (or symbolic models) solves this by partitioning continuous state spaces into finite, discrete representations. By transforming complex differential equations into manageable transition graphs, researchers can apply powerful tools from computer science, such as model checking and game theory, to physical engineering.

The Infinite State Problem

Traditional control theory often relies on simulation or Lyapunov functions to prove stability. While effective, these methods struggle with complex logic, such as "navigate to point A, then B, while avoiding C unless D happens." Computer science excels at this type of reasoning using discrete models like Finite State Automata.

The challenge, as noted by Giordano Pola, is that mapping infinite continuous states to a finite symbolic representation requires extreme precision. If the abstraction is too coarse, the controller might miss a critical safety boundary; if it is too fine, the "state-space explosion" makes the problem computationally impossible.

Discretization through State Space Partitioning

The core mechanism of this research is the systematic partitioning of the state space. Instead of treating every possible position of a robot as a unique state, researchers like Bing-Wen Wang and Yiping Gua use cell mapping. They divide the continuous domain into a grid of disjoint "cells."

Each cell becomes a "symbol" in a discrete model. A transition occurs when the system's dynamics move it from one cell to another over a fixed time interval. Antoine Girard and Giordano Pola demonstrated that for "incrementally stable" systems, these grid-based symbolic models can be approximately bisimilar to the original system. This means that any behavior possible in the continuous system is captured by the discrete model, and vice versa, within a known error bound.

Bridging Logic and Physics with Bisimulation

To trust a discrete model, we need a formal link to the underlying physics. This link is often established through bisimulation relations. Majid Zamani and colleagues expanded this by showing that even nonlinear systems without traditional stability assumptions can be abstracted into symbolic models.

By using uniform quantization—essentially a high-dimensional lattice—researchers can treat discretization errors as non-deterministic "noise." As Jonathan DeCastro and Matthias Rungger argue, this allows the controller to treat the physical constraints of the hardware (like inertia) as part of the environment's behavior, ensuring the high-level mission logic remains physically achievable.

Handling Randomness via Stochastic Abstractions

Many real-world systems are not just continuous; they are stochastic. Whether it's wind gusts hitting a drone or fluctuating demand on a power grid, randomness is inherent. Alessandro Abate and Sadegh Soudjani have pioneered methods to abstract these Stochastic Hybrid Systems into finite-state Markov Decision Processes (MDPs) or Interval MDPs.

Tools like FAUST$^2$ automate this process, partitioning the domain into bins and calculating transition probabilities between them. This allows for "probably approximately correct" (PAC) safety guarantees. For instance, Thom Badings and Alessandro Abate have used these abstractions to design robust controllers for systems with unknown, non-Gaussian noise by combining formal methods with data-driven sampling.

From Verification to Synthesis

The ultimate goal of this research is not just to check if a system is safe, but to automatically build a controller that makes it so. By converting a control problem into a graph search or a game-theoretic problem, researchers can synthesize "provably correct" logic.

  • Vehicle Navigation: Calin Belta and Morteza Lahijanian use polygonal partitions to navigate vehicles through hostile environments, maximizing the probability of mission success.
  • Infrastructure: Ben Wooding applied symbolic synthesis to regulate power grid frequency using electric vehicles, providing guarantees that simulation alone cannot offer.
  • Efficiency: Kazumune Hashimoto has shown that by mapping invariant "safe zones" to nodes in a graph, controllers can determine the optimal time to trigger sensor updates, saving energy while maintaining stability.

By treating quantization not as a nuisance, but as a formal mathematical tool, this field provides the rigorous foundation needed for autonomous systems to operate safely in an unpredictable, continuous world.

Papers in this version

Showing 60 of 62 papers.

History & citationVersion 1 · 2026-10-04

Split into other directions · Permanent link

View frozen version 1

Cite this direction

Latest version (a living page):

@misc{lacuna_formal_abstractions_for_continuous_and_s_c355cf69,
  title = {Formal Abstractions for Continuous and Stochastic Control Systems},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/formal-abstractions-for-continuous-and-stochastic-control-systems/rdr_c355cf697ff64606bdecb1e45dfcb9d6},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-20},
}

This exact version (version 1, frozen text):

@misc{lacuna_formal_abstractions_for_continuous_and_s_c355cf69_v1,
  title = {Formal Abstractions for Continuous and Stochastic Control Systems},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/formal-abstractions-for-continuous-and-stochastic-control-systems/rdr_c355cf697ff64606bdecb1e45dfcb9d6/v/1},
  note = {Version 1, frozen 2026-10-04. Accessed 2026-11-20},
}