Latent Space Element Method (LSEM)

• LSEM is a non-intrusive, element-based surrogate modeling framework that leverages local latent ODE surrogates to approximate and predict PDE dynamics.
• It employs a modular autoencoder-based architecture to learn and couple local latent dynamics, enabling scalable simulation across varying geometries.
• The method eliminates the need for intrusive PDE operator access and Schwarz iterations, delivering rapid inference and smooth, artifact-free solution reconstructions.

The Latent Space Element Method (LSEM) is a non-intrusive, element-based surrogate modeling framework for partial differential equations (PDEs) that leverages local latent-space ordinary differential equation (ODE) surrogates, direct latent coupling, and smooth reconstruction. It enables scalable, geometry-flexible, and interpretable surrogate solvers that can train efficiently on small reference domains and predict on arbitrarily large or heterogeneous assemblies, without requiring intrusive access to PDE residuals or operator code. This approach generalizes the Data-Driven Finite Element Method (DD-FEM) paradigm in a fully latent and non-intrusive manner, avoiding Schwarz interface iterations and enabling rapid inference on domains and initial conditions far outside the training set (Chung et al., 5 Jan 2026).

1. Motivation and Conceptual Foundations

Reduced-order modeling (ROM) and data-driven surrogate methods have revolutionized scientific computing for PDEs, but their traditional formulations are limited by two core constraints: (i) the need for intrusive access to underlying PDE operators (as in projection-based POD-Galerkin and SINDy-ROMs) and (ii) inflexibility to varying geometries or domain sizes (as in standard neural operators and many physics-informed neural networks) (Chung et al., 5 Jan 2026). DD-FEM introduced the notion of reusable, localized ROMs associated with finite elements and classical domain decomposition, but existing frameworks incur substantial overhead from iterative Schwarz coupling and require intrusive element-level operator extraction.

LSEM eliminates both bottlenecks by learning a set of transferable, local latent ODE surrogates ("elements") trained using only high-fidelity solution snapshots over small reference patches. Domain-scale PDE surrogates are then assembled by coupling latent blocks directly through learned, direction-specific latent fluxes, reconstructing the global solution via window-based partition-of-unity blending. This approach delivers a “train small, predict large” paradigm for surrogate PDE solvers, enabling extensible and scalable scientific computing on domains and source conditions not seen during training (Chung et al., 5 Jan 2026).

2. Single-Element Model and Latent ODE Surrogates

Each LSEM "element" is associated with an autoencoder—composed of an encoder $En_m: \mathbb{R}^{N_m} \to \mathbb{R}^{N_z}$ and a decoder $De_m: \mathbb{R}^{N_z} \to \mathbb{R}^{N_m}$—mapping local high-dimensional states $q_m(t)$ to a low-dimensional latent $z_m(t)$, and approximating $q_m(t) \approx De_m(z_m(t))$.

Local dynamics are modeled by a learned latent ODE,

$$\dot z_m(t) = f_{\rm elem}(z_m(t)), \quad f_{\rm elem}(z) = \Xi_D \Theta(z),$$

where $\Theta(z)$ is a feature library (polynomial or nonlinear in $z$), and $\Xi_D$ is a learnable coefficient matrix. In the simplest linear case, $f_{\rm elem}(z) = A_D z$. Eigenvalue-based regularization for $A_D$ ensures dynamical stability when required. Encoder/decoder architectures for 1D Burgers’ and KdV equations utilize fully connected layers (e.g., $[N_m, 100, 30, N_z]$), with softplus or $\tanh$ activations (Chung et al., 5 Jan 2026).

3. Latent Coupling and Global System Assembly

Neighboring elements exchange information in latent space through directionally parameterized coupling blocks. For element $i$ with latent $z_i$ and set of neighbors $N(i)$,

$$\dot z_i = \Xi_D \Theta(z_i) + \sum_{j \in N(i)} \Xi_{i \to j} \Theta(z_j)$$

where each direction (e.g., left/right, upwind/downwind) admits its own learnable matrix $\Xi_{\rm dir}$. The global latent state $Z(t) = [z_1; z_2; \ldots; z_{N_{\rm elems}}]$ then evolves by

$\dot Z(t) = \Xi \Theta(Z(t))$

with block-diagonal (internal) and off-diagonal (directional coupling) structure in $\Xi$. The coupling is trained end-to-end within the global latent-dynamics loss, without the need for explicit interface residuals or Schwarz iterations. The exact directional decomposition is problem-dependent (e.g., $\ell, r$ for 1D, upwind/downwind for hyperbolic PDEs) (Chung et al., 5 Jan 2026).

4. Field Reconstruction and Partition-of-Unity Blending

To reconstruct the high-dimensional global solution $\hat u(x, t)$ from overlapping per-element predictions $\hat q_m(x, t) = De_m(z_m(t))$, LSEM employs a smooth window-based blending: $$\widehat u(x, t) = \sum_{m=1}^{N_{\rm elems}} w_m(x) \widehat q_m(x, t)$$ where $w_m(x)$ are compactly supported, $C^1$ cosine windows, typically possessing exact partition-of-unity properties, thus ensuring smoothness and continuity across element boundaries even for overlapping tiles. This eliminates the need for explicit interface corrections and yields mesh-free, artifact-free solution interpolations (Chung et al., 5 Jan 2026).

5. Training Protocols and Hyperparameters

Training of LSEM is conducted entirely in a non-intrusive fashion:

• Snapshot collection: Multiple high-fidelity simulations on small reference assemblies (e.g., 4-element overlaps) yield snapshot collections.
• Subdomain extraction: Each global state $Q^{(n)}(t_k)$ is restricted to element $m$ as $q_m^{(n)}(t_k) = R_m Q^{(n)}(t_k)$.
• Autoencoders: Each element model is trained to minimize

$$J_{AE} = \frac{1}{\sum_n}\sum_{n,m,k} \left\|q_m^{(n)}(t_k) - De_m(En_m(q_m^{(n)}(t_k)) + \delta z)\right\|^2$$

with additive latent noise $\delta z \sim \mathcal{N}(0, \epsilon(t_k)^2)$ regularizing decoder stability.

• Latent-dynamics and coupling training: The joint loss

$$J_{LD} = \frac{1}{\sum_n} \sum_n \|D_t Z^{(n)} - \Xi \Theta(Z^{(n)})\|^2_F$$

supervises both internal and coupling dynamics, with stability regularization where needed (e.g., $$J_{reg} = \sum_{\lambda\in\sigma(\Xi)} {\rm ReLU}(\Re\lambda)^2$$ for linear $\Xi$).

• Optimization: Hyperparameters for tested systems include $N_z=5$ (Burgers), layers $[639,100,30,5]$ and learning rate $3\times 10^{-3}$ for 2000 epochs, or $N_z=7$ and deeper networks for KdV, trained via Adam or SOAP (Chung et al., 5 Jan 2026).

6. Numerical Experiments and Scalability

LSEM has been validated on the 1D Burgers’ and Korteweg–de Vries equations. In both, models trained on 4 overlapping elements generalize to assemblies with 12–24 elements—spatial domains up to 6–8 times larger than in training—without retraining or Schwarz iterations:

• Burgers’ equation: Training error relative $L_2 = 0.51\%$, scaled-domain error $0.41\%$, inference $32\times$ faster than FOM.
• KdV equation: Training error $5.64\%$, scaled-domain $11.7\%$, inference speedup $5500\times$ FOM. Reconstructed solution fields show smoothness across interfaces with no mode-jumping or artifacts. The method scales linearly in domain size due to the block structure of the assembled latent ODE, and prediction leverages the same trained local models in new configurations (Chung et al., 5 Jan 2026).

7. Interpretability, Limitations, and Future Directions

LSEM explicitly separates internal subdomain dynamics from direction-resolved latent coupling, with analogous structure to numerical flux stencils in conventional discretizations. This yields interpretability of learned operators and clarity in error analysis. The method’s non-intrusiveness reduces the reliance on operator-level access, requiring only solution snapshots for training.

Current limitations include restriction to one-dimensional problems and structured overlaps; extension to 2D and 3D will require adaptation of windowing, latent coupling, and possibly incorporation of CNN/GNN-based architectures. Expanding LSEM to more complex PDEs (multiphysics, turbulence), unstructured meshes, and adaptive element refinement are open directions. Integration with uncertainty quantification and multi-fidelity modeling are noted prospects (Chung et al., 5 Jan 2026).

LSEM establishes a foundation-model approach to surrogate PDE solvers by combining the geometric flexibility of modular local models with the scalability and interpretability of latent dynamical systems, without reliance on PDE operator intrusiveness. This represents a convergence of advances in latent PDE solvers and domain-decomposition-inspired surrogate assembly (Ranade et al., 2021, Chung et al., 5 Jan 2026).