Extending Deterministic Dynamical Frameworks to Stochastic Systems

38 concepts41 papers2 proposals

When modeling a physical or computational system, the cleanest assumption we can make is determinism: given a current state and a specific action, the next state is perfectly predictable. This assumption underpins classical control theory, formal verification, and many deep learning models for dynamics. It allows researchers to compute exact future trajectories, map clean manifolds, and guarantee absolute safety boundaries.

However, the real world is rarely perfectly predictable. Wind gusts buffet autonomous drones, measurement devices introduce sensor noise, and complex systems experience sudden, random environmental fluctuations. A major shared frontier across machine learning, control theory, and formal verification is breaking free from this baseline assumption to robustly handle stochastic dynamics.

The Breakdown of Optimal Control and Trajectory Planning

In optimal control, frameworks like Model Predictive Control (MPC) and Differential Dynamic Programming (DDP) iteratively optimize trajectories over a time horizon. When transitions are deterministic, these algorithms can precisely map out future states.

For instance, Stachowicz et al. extended the DDP framework to dynamically determine optimal time horizons for robotic tasks. However, their formulation relies on deterministic dynamics; when transitions become stochastic, open-loop planning struggles because the system cannot anticipate the variance of future states.

Similarly, in Inverse Reinforcement Learning (IRL)—where the goal is to recover underlying reward functions from expert demonstrations—algorithms often rely on clean trajectory rollouts. Cao et al. developed a closed-loop DDP framework capable of processing noisy expert data, yet the underlying optimization remains fundamentally rooted in a deterministic formulation of system behavior, leaving it unequipped for environments with true stochastic transition dynamics.

Deterministic Control:  [State S0] --(Action A)--> [Exact State S1] --(Action B)--> [Exact State S2]
Stochastic Reality:     [State S0] --(Action A)--> [Distribution over S1] --?--> [High Variance States]

Even data-driven linearizations of complex systems face this barrier. Koopman operator theory attempts to discover linear representations of nonlinear dynamics to simplify control. Yet, as seen in work by Chen et al., these deep reinforcement learning integrations are currently limited to fully observed, deterministic autonomous systems. To make these control strategies viable in real-world deployments, researchers must find ways to inject stochasticity directly into the core optimization loops.

The Challenge of Verifying Safety and Stability

Formal verification seeks to mathematically prove that a system will never enter an unsafe state. This is typically achieved by synthesizing "certificates"—such as Lyapunov functions for stability or Control Barrier Functions (CBFs) for safety—that act as rigid geometric boundaries around allowed states.

When a system is deterministic, these boundaries are absolute. Edwards et al. leveraged neural networks and Satisfiability Modulo Theories (SMT) solvers to automate certificate synthesis, but the framework is strictly designed for deterministic systems. Similarly, the data-driven certificate synthesis method by Rickard et al. maps trajectories to guarantee safety, but relies on a deterministic baseline.

When random noise enters the equation, a rigid boundary can be breached by a single low-probability fluctuation. To fix this, researchers are shifting toward Stochastic Control Barrier Functions (SCBFs), which provide probabilistic safety guarantees rather than absolute ones. Meng et al. demonstrated that neural networks can learn approximations of SCBFs to guarantee safety under unknown noise dynamics. However, even their approach assumes the underlying drift dynamics are known, highlighting how deeply embedded deterministic assumptions remain.

State Abstractions and Latent Representations

To manage high-dimensional or hybrid systems (which switch between continuous movements and discrete modes), researchers often build simplified "abstractions" or compress the state space into a lower-dimensional latent manifold.

  • Hybrid Systems: Teng et al. introduced CHyLL to learn continuous neural representations of hybrid systems, overcoming discontinuities and mode switches. However, the model assumes deterministic dynamics and complete observability.
  • Macroscopic Models: When creating simplified macroscopic models from complex microscopic simulations, Dietrich et al. used time-lagged embeddings and diffusion maps, but noted that extending this methodology to robustly handle stochastic systems remains an open research question.

A major mathematical hurdle in creating these abstractions is measuring the error between the true system and the simplified model. In a deterministic world, simple geometric distances suffice. To bridge the gap to stochasticity, Banse et al. proposed using a Kantorovich-inspired metric for data-driven abstractions. This probabilistic metric efficiently measures differences between distributions rather than exact points, providing a framework that could theoretically generalize to stochastic systems, though empirical validation in random environments remains an active area of study.

From Smooth Trajectories to Random Forcing and Jumps

The transition from deterministic to stochastic dynamics fundamentally alters the long-term behavior of complex physical and mathematical systems. In climate modeling, for example, systems can experience sudden shifts or "tipping points."

Rachel Kuske demonstrated that non-smoothness in climate models causes rapid, unpredictable tipping points under deterministic seasonal forcing, but noted that validating whether these jagged tipping patterns survive stochastic environmental noise is a critical open question. Similarly, Lucarini et al. combined Neural Ordinary Differential Equations (NODEs) with bifurcation analysis to predict chaotic states, but their empirical validation remains limited to deterministic systems.

Deterministic Forcing:  [Smooth Seasonal Cycle] ---------> [Predictable Tipping Point]
Stochastic Forcing:     [Cycle + Random Noise] ----------> [Early/Delayed Probabilistic Tipping]

From a pure partial differential equation (PDE) perspective, Khanin et al. studied the uniform exponential contraction of Hamilton-Jacobi equations, bridging the gap from viscous (stochastic) to inviscid (deterministic) settings. Yet, their framework is currently limited to deterministic potentials rather than truly random forcing.

When systems explicitly feature both continuous and discrete random disturbances—such as jump-diffusion systems—the math becomes incredibly intricate. Tang et al. derived explicit feedback strategies for these systems, but were still forced to assume deterministic coefficients for the system dynamics and cost functions, leaving random coefficients as an open problem.

Non-Determinism in Software and Logic Systems

The challenge of the deterministic assumption extends beyond physical systems into program analysis and logic programming, where non-determinism arises from concurrency or randomized algorithms.

In automated program analysis, Menguy et al. developed a framework to infer function preconditions from input-output examples, but the method assumes deterministic functions, making it inapplicable to concurrent or randomized code. In active learning for software components, Radhakrishna et al. built a tool to learn callback typestates for Android classes under a strict determinism assumption, requiring manual user intervention when non-determinism is encountered.

Even in pure logic programming, algebraic concepts like the grounded fixpoints introduced by Bogaerts et al. are currently restricted to deterministic operators. Extending these theories to handle non-deterministic operators—where a single state can lead to multiple possible next states—remains an open theoretical frontier.

Conclusion

Across control theory, machine learning, and formal verification, the deterministic system assumption serves as a powerful scaffolding that allows researchers to build initial frameworks and prove core theorems. The current trajectory of this research field is focused on systematically dismantling this scaffolding—replacing rigid trajectories with probability distributions, absolute safety boundaries with stochastic certificates, and deterministic metrics with optimal transport tools like the Kantorovich metric. The ultimate goal is to retain the computational efficiency of deterministic algorithms while embedding the probabilistic robustness required for the real world.

Key Foundational Work

Demonstration of Genesys: A Very Large, Semantically Based Systemic Functional Generator (1990) — contributed 1 concept elements to this direction.
An Improved Constraint-Propagation Algorithm for Diagnosis (1987) — contributed 1 concept elements to this direction.
History & citationVersion 1 · 2026-10-04

Current · Permanent link

View frozen version 1

Cite this direction

Latest version (a living page):

@misc{lacuna_deterministic_system_assumption_4192a4f2,
  title = {deterministic system assumption},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/deterministic-system-assumption/rdr_4192a4f23d63436284f0ba9bbf9f0ef3},
  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_deterministic_system_assumption_4192a4f2_v1,
  title = {deterministic system assumption},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/deterministic-system-assumption/rdr_4192a4f23d63436284f0ba9bbf9f0ef3/v/1},
  note = {Version 1, frozen 2026-10-04. Accessed 2026-11-20},
}
About

These directions overlap with this one through shared papers.

See something wrong? Report a mistake