Unified Multi-Dynamics Modeling Framework

• The unified multi-dynamics modeling framework is a formal system that combines continuous ODEs, algebraic constraints, and discrete-event dynamics into a single parametrizable model.
• It employs a Hybrid, Unified Differential-Algebraic (HUDA-ODE) formulation to seamlessly integrate various dynamical behaviors while addressing algebraic loops and state resets.
• A learnable wildcard connection architecture enables gradient-based optimization and interpretability, ensuring loop-free composition of heterogeneous submodels.

A unified multi-dynamics modeling framework is a formal system capable of representing, learning, and optimally combining dynamical models that span multiple mathematical types—including ordinary differential equations (ODEs), algebraic constraints, and discrete-event (reset) dynamics—within a single, expressive, and parametrizable architecture. The central goal is to enable systematic composition of heterogeneous submodels, support gradient-based learning, and facilitate interpretable model combination, while addressing key system-theoretic obstacles such as algebraic loops and discontinuous event-induced state resets (Thummerer et al., 2024).

1. Unified Mixed-Dynamics Model Class: HUDA-ODE Formulation

At the mathematical core of the framework is the Hybrid, Unified, Differential-Algebraic (HUDA-ODE) class. This model collects in a single state vector:

• Continuous-time variables $x_c(t)$: evolve according to (possibly nonlinear) ODEs.
• Discrete/event variables $x_d(t)$: piecewise-constant except at event instants.
• Algebraic outputs $y(t)$: defined as functions of ($x_c$, $x_d$, input $u$, parameters $\theta$, time).
• Event-condition outputs $z(t)$: indicate discontinuities or switching, e.g., threshold crossings.

The HUDA-ODE evolution is given by: $$\begin{aligned} \dot x_c(t)\;&=\;f\bigl(x_c(t),\,x_d(t),\,u(t),\,\theta,t\bigr),\ \dot x_d(t)\;&=\;0,\ y(t)\;&=\;g\bigl(x_c(t),\,x_d(t),\,u(t),\,\theta,t\bigr),\ z(t)\;&=\;c\bigl(x_c(t),\,x_d(t),\,u(t),\,\theta,t\bigr),\ \end{aligned}$$ where integration is performed up to an event time $t_e$ when any component of $x_d(t)$0 crosses zero. At event instants: $x_d(t)$1 where $x_d(t)$2 is a reset (discrete update) map. In a constraint-oriented notation: $x_d(t)$3 This unified class subsumes pure ODEs ($x_d(t)$4), static algebraic blocks ($x_d(t)$5), purely discrete-time or hybrid dynamics ($x_d(t)$6), and their cascades (Thummerer et al., 2024).

2. Model Combination and System-Theoretic Challenges

Arbitrary combinations of submodels, especially those mixing direct feed-through (algebraic) and stateful (dynamic) blocks, induce critical issues:

• Algebraic loops arise when two or more algebraic outputs depend cyclically on each other (e.g., $x_d(t)$7 with $x_d(t)$8, $x_d(t)$9), forming an implicit system that cannot be forward-simulated directly without a nonlinear solver. These are addressed either by (a) automatic loop detection (block-level Tarjan or BLT decomposition), followed by a Newton or belief-propagation inner solve; or (b) by designing interconnection matrices (sparsity in $y(t)$0) a priori to eliminate cycles.
• Local event functions and reset consistency: When a discrete event in one block (e.g., $y(t)$1) occurs, the new block state must be globally consistent with all other coupled blocks—often requiring a localized algebraic solve for the input slice that ensures system consistency at the event instant. The residual for this solve is explicitly constructed, e.g.,

$y(t)$2

solved to match the dissipative state transitions across the network (Thummerer et al., 2024).

3. Learnable and Interpretable Wildcard Connection Architecture

A primary innovation is the "wildcard" architecture for learnable, interpretable model combination. Given two (possibly complex) submodels $y(t)$3, their connection is parameterized via three trainable linear layers: $y(t)$4 System-theoretic loop-freedom is enforced by imposing sparsity constraints on $y(t)$5, typically requiring $y(t)$6, and exactly one of $y(t)$7 or $y(t)$8, disallowing direct cycles. Each subblock of $y(t)$9 has a clear interpretive meaning: parallel gains from inputs, sequential (cascade) links, residual (skip) connections in the output, and direct feed-through.

The learning procedure is fully differentiable: the global parameter vector $x_c$0 comprises all $x_c$1; training data ($x_c$2) is rolled out through the full solver (ODE, events, submodels, linear connections), a scalar loss $x_c$3 (e.g., squared error) is evaluated, and gradients are computed and propagated back through all layers including the ODE/event engine, enabling efficient gradient-based optimization (e.g., Adam) (Thummerer et al., 2024).

4. Illustrative Example and Training Workflow

The framework's flexibility is demonstrated in a concise example:

• Continuous submodel a: first-order ODE, $x_c$4, $x_c$5.
• Discrete submodel b: single-step map, $x_c$6, $x_c$7. The wildcard-parameterized connection is: $x_c$8 Forward propagation integrates the ODE until the event condition triggers ($x_c$9), then applies the discrete map to $x_d$0, outputs $x_d$1, and continues.

Training consists of collecting input-output trajectories, rolling out the full system, evaluating loss, and updating parameters via backpropagation through the dynamics and linear mappings. This integrates system-theoretic interpretability, empirical accuracy, and broad extensibility within a unified pipeline (Thummerer et al., 2024).

5. Expressive Power, Extensibility, and Theoretical Guarantees

The model class underlying the framework is maximally expressive for dynamical systems encountered in practice:

• Any composition of (nonlinear) ODEs, algebraic feed-through maps (including neural nets), discrete-event or reset (map) systems, and their cascades is representable.
• Hybrid systems, including those with piecewise-smooth, switched, or event-driven behavior, are encoded via state partition, event conditions, and instantaneous resets.
• The loop-free design guarantees that forward simulation, loss evaluation, and sensitivity/backpropagation are always well-posed—no hidden algebraic cycles or inconsistent discrete events.
• All optimization is implemented within a standard autodiff framework, enabling both learning and interpretability.

The HUDA-ODE plus wildcard architecture thus unifies the design, learning, and analysis of complex dynamical systems under a single, transparent formalism. The resulting system is fully differentiable, interpretable in both system-theoretic and neural-network terms, and adaptable to arbitrary structural priors on the modeling graph (Thummerer et al., 2024).

6. Impact, Limitations, and Software Implementation

This unified approach enables principled and data-efficient learning of complex system dynamics, permits explicit encoding and learning of blockwise model connections, and is capable of handling real-world scenarios involving mixed physical and machine-learned components.

Limitations include:

• The need for careful design of connection-matrix parameterizations to avoid hidden algebraic loops.
• Dependence on event-detection and local consistency solves for correct discontinuity handling.
• Loop-free restrictions, while necessary for correctness, may preclude some expressivity unless additional fixed-point or root-solving machinery is allowed in the modeling engine.

Public implementation and methodology are available as referenced in (Thummerer et al., 2024), providing a basis for adoption and further development across diverse modeling domains.

---

Primary Source: "Learnable & Interpretable Model Combination in Dynamical Systems Modeling" (Thummerer et al., 2024).