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 $z(t)$ crosses zero. At event instants: $$x\bigl(t_e^+\bigr) = a\left(x\bigl(t_e^-\bigr), u(t_e), \theta, t_e\right)$$ where $a$ is a reset (discrete update) map. In a constraint-oriented notation: $$\begin{aligned} 0 &= f(x_c, x_d, u, \theta, t) - \dot x_c, \ 0 &= g(x_c, x_d, u, \theta, t) - y, \ 0 &= c(x_c, x_d, u, \theta, t) - z, \ x(t^+) &= a(x(t^-), u(t), \theta), \end{aligned}$$ This unified class subsumes pure ODEs ($g,c,a\equiv0$), static algebraic blocks ($f\equiv0$), purely discrete-time or hybrid dynamics ($\dot x_d=0, a\neq0$), 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., $y_a = f_a(u_a),\, y_b = f_b(u_b)$ with $u_a = W_{ab}\,y_b + ...$, $u_b = W_{ba}\,y_a + ...$), 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 $W$) a priori to eliminate cycles.
• Local event functions and reset consistency: When a discrete event in one block (e.g., $x_b(t^-)\mapsto x_b(t^+)$) 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.,

$$r(u_z) = \| W_{ba} f_a(W_{az} u_z) + W_{bz} u_z - u_b \|,$$

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 $a, b$, their connection is parameterized via three trainable linear layers: $$\begin{aligned} u_a &= W_{aa}\,y_a + W_{ab}\,y_b + W_{az}\,u_z + b_a, \ u_b &= W_{ba}\,y_a + W_{bb}\,y_b + W_{bz}\,u_z + b_b, \ y_z &= W_{za}\,y_a + W_{zb}\,y_b + W_{zz}\,u_z + b_z. \end{aligned}$$ System-theoretic loop-freedom is enforced by imposing sparsity constraints on $W$, typically requiring $W_{aa}=W_{bb}=0$, and exactly one of $W_{ab}=0$ or $W_{ba}=0$, disallowing direct cycles. Each subblock of $W$ 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 $\theta$ comprises all $W_{ij}, b_i$; training data ($u_z, y_{\mathrm{target}}$) is rolled out through the full solver (ODE, events, submodels, linear connections), a scalar loss $\mathcal L$ (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, $\dot x_a = -\alpha x_a + \beta u_a$, $y_a = x_a$.
• Discrete submodel b: single-step map, $x_b^+ = H x_b^- + K u_b$, $y_b = x_b$. The wildcard-parameterized connection is: $$\begin{aligned} u_a &= W_{az}\,u_z, \ u_b &= W_{ba}\,y_a + W_{bz}\,u_z, \ y_z &= W_{za}\,y_a + W_{zb}\,y_b. \end{aligned}$$ Forward propagation integrates the ODE until the event condition triggers ($c(x_a)=0$), then applies the discrete map to $x_b$, outputs $y_z$, 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).