Local Energies, Global Solver: Non-Local Proposals for Composable Energy Surrogates

A promising way to simulate large mechanical structures, such as metamaterials built from repeated cells with holes and struts, is to learn the stored energy of a single cell as a function of how its boundary is displaced. You then assemble many cells and find the configuration that minimizes their summed energy. Learning Composable Energy Surrogates for PDE Order Reduction showed that a surrogate trained on 2×2-pore cells composes into 8×8 arrays that reproduce nonlinear pore collapse, at the accuracy of finite-element models that use an order of magnitude more variables. The weak point sits in the solver, not in the energy. Every cell sees only its own boundary, so information about a distant load, or a buckling mode that spans the whole array, has to travel through the iterations of a generic numerical optimizer. That optimizer wanders into boundary states the surrogate never saw. It needs expensive active resampling (DAGGER) to stay on track, and it can settle into the wrong buckling pattern.

The tempting fix is to give each cell's energy network a global receptive field, for example with attention over the whole array. We argue this is the wrong place to put non-locality. A cell's elastic energy really does depend only on its own boundary displacement. That fact is what makes energies additive and lets a model trained on small pieces scale up without retraining. We propose to keep the energies strictly local and to add the global receptive field to a learned proposer. The proposer reads the whole module grid and outputs a full-array guess of the interface displacements, including the long-wavelength mode. The exact composed-energy minimization then refines that guess. The physics stays local and additive, and the cross-array reasoning happens in the part of the pipeline that actually needs it.

Core Claim

Our claim is that amortizing the global part of composed-energy minimization with a size-agnostic non-local network gives three improvements, and that each can be measured separately. First, the solver picks the correct buckling branch more often on structures whose instability is global. Second, it needs fewer optimizer iterations and much less active resampling, because the refinement starts near the in-distribution region of the surrogate. Third, it keeps the zero-shot scaling of the composed model, because the proposer uses no absolute coordinates and the energy is unchanged. Concretely, the system solves

$$u^\star = \arg\min_u \; \sum_{c=1}^{C} E_\theta\!\left(u|_{\partial\Omega_c}\right) - f^\top u, \qquad u^{(0)} = G_\phi(f, \text{geometry}),$$

where $u$ collects the shared boundary control points of all $C$ cells and $u|_{\partial\Omega_c}$ is the part of $u$ on cell $c$'s boundary. $E_\theta$ is the frozen local energy surrogate, $f$ is the vector of external loads, and $G_\phi$ is the non-local proposer whose output $u^{(0)}$ initializes the minimization.

Research Program

The local energy $E_\theta$ is a Composable Energy Surrogate trained as in Learning Composable Energy Surrogates for PDE Order Reduction: it takes spline-parameterized boundary displacements as input and is fitted to energies, forces and Hessians computed by finite elements. We reuse that method unchanged so that every difference we measure comes from the solver side.

The proposer $G_\phi$ treats the array as a 2D grid of tokens, one per cell. Each token carries that cell's local geometry, the loads applied to it, and its boundary type. Because the array is a regular lattice, recurrent criss-cross attention from CCNet: Criss-Cross Attention for Semantic Segmentation fits it directly. That paper attends along each token's row and column, and two passes give every cell a path to every other cell at $O(N\sqrt{N})$ cost; it reports 11x less memory and 85% fewer FLOPs than a dense non-local block. Our use differs from CCNet's. There it serves dense image labeling; here its output is a displacement field that a physics-exact optimizer must accept or correct. We use relative position encodings only. Absolute coordinate channels, as in the broadcasting network of Broadcasting Convolutional Network for Visual Relational Reasoning, would tie the proposer to the training array size, so we test them only as an ablation.

We train $G_\phi$ against the energy itself. The loss is the composed energy evaluated after $K$ unrolled refinement steps started from $G_\phi$'s output. This loss needs no labeled solutions, which matters because finite-element labels for large arrays are what we are trying to avoid. A small supervised term on cheap finite-element solutions of arrays up to 4×4 resolves branch selection, since the energy alone cannot tell which of two symmetric buckling modes to choose. We also add a penalty on the distance from $u^{(0)}$ to the surrogate's training distribution of boundary states, so the proposer learns to land where $E_\theta$ can be trusted.

Two lines of prior work shape the design. The first motivates the use of energy structure. The physics-informed graph network benchmark in Unravelling the Performance of Physics-informed Graph Neural Networks for Dynamical Systems and the chain experiments of Learning Articulated Rigid Body Dynamics with Lagrangian Graph Neural Network found that additive, decoupled energies are what give zero-shot scaling, from 5-link to 50-link springs and from 4-segment to 100-link chains. This is why we refuse to make the energy non-local. The second line supplies a competing route to long-range communication. Improving Long-Range Interactions in Graph Neural Simulators via Hamiltonian Dynamics broadcasts boundary context through a multi-round message-passing warmup inside a port-Hamiltonian simulator. Port-Hamiltonian Architectural Bias for Long-Range Propagation in Deep Graph Networks propagates signals without loss through up to 1,000 symplectic layers. Both models are monolithic simulators or abstract graph learners; neither composes reusable energy modules or feeds a variational equilibrium solve. We borrow their routing as a competing proposer architecture, not as the energy model.

Baselines

The naive reference is CES exactly as published. The minimization starts from zero or affine-interpolated interface displacements, uses the surrogate's Newton/L-BFGS solver, and runs with no resampling. This shows how often a purely local pipeline finds the right global mode.

The strongest existing method is CES with DAGGER active resampling on the deployment load paths. This is the published remedy for out-of-distribution drift, and the paper's own large-array results depend on it. We give it the same number of finite-element calls for resampling that our method spends on proposer supervision, so the two use equal labeling budgets. Beating it means reaching equal or lower displacement error against fine finite elements with fewer total finite-element calls, and picking the correct buckling branch more often on the global-instability arrays. The CES paper gives no numeric errors or runtimes, only relative claims, so there is no reported result found on Lacuna for CES's exact $L^2$ error on the 8×8 benchmark. We will regenerate this baseline ourselves.

A classical two-level baseline initializes the minimization from a coarse finite-element solve of the homogenized array. Coarse finite elements alone were shown in the CES paper to be orders of magnitude less accurate, but here they only supply the starting point, as a coarse correction does in domain decomposition. This is the most dangerous competitor, and we tune its mesh resolution so its wall-clock time matches the proposer's.

A message-passing proposer replaces criss-cross attention with port-Hamiltonian message passing over the cell graph, in the style of the IGNS warmup and PH-DGN. The depth is set so that information can cross the array diameter, and the parameter count and training loss match ours. This isolates whether factorized attention matters or whether any lossless long-range router suffices.

Three ablations isolate our key ingredient. The first gives the proposer only a 3×3 local receptive field over cells. The second injects the proposer's global features into $E_\theta$ itself, which is the "non-local energy" design. The third uses the proposer's output with no refinement. If the 3×3 proposer matches the full proposer, the non-local receptive field buys nothing.

Why not just…?

Why not just give each cell's energy network global context? Doing so makes $E_c$ depend on other cells, so the total is no longer a sum of independent parts. The equilibrium condition then picks up spurious cross-terms, much like the mixed-input monolithic models that Unravelling the Performance of Physics-informed Graph Neural Networks for Dynamical Systems found to break conservation. We expect this variant to fit the training array sizes well and to degrade as arrays grow. The second ablation tests exactly this on arrays of 16×16 and 32×32.

Why not just initialize from coarse finite elements? This is a real threat, because coarse solves capture long-wavelength modes cheaply. Their weakness is near bifurcations. When pores collapse, the homogenized coarse model can miss the instability or choose the wrong pattern, which is the regime where the CES paper found coarse meshes failing. If the coarse-FEA baseline matches our branch accuracy and iteration counts at equal wall-clock time, we will report that the learned non-local proposer is unnecessary, and we will narrow the claim to the cases, if any, where it still wins.

Why not just train a vision transformer to predict the displacement field directly? A direct predictor has a global receptive field but offers no guarantee that its output is an energy minimum. It also inherits the rollout and drift failures that Improving Long-Range Interactions in Graph Neural Simulators via Hamiltonian Dynamics documents for unconstrained simulators. The third ablation, the proposer with no refinement, is this design evaluated on the same data, and it measures how much the exact energy step contributes.

Why not just run more optimizer iterations, or add load continuation and restarts? These eventually converge, but they still walk through the same off-distribution boundary states. They are also blind to which branch is correct. We include load continuation with a matched iteration budget inside the naive baseline, and we report error against iterations so the cost of brute force is visible.

Proposed Experiments

We follow the parametric metamaterial setting of the CES benchmark. That means 2D hyperelastic cells with circular pores of varying size and porosity, under compression, shear and mixed boundary loads, with ground truth from fine-mesh finite elements. The surrogate and the proposer see arrays of at most 4×4 cells. We test zero-shot on 8×8, 16×16 and 32×32 square arrays.

We add two families designed so that locality must fail. The first is slender 2×32 and 4×64 columns under axial compression, where the dominant instability is global Euler-type bending of the whole array rather than local pore collapse. The second is arrays loaded at one end with the far boundary clamped, where interior response depends on information from many cells away.

The metrics are $L^2$ displacement error against fine finite elements; the composed energy at convergence, where lower is better when the finite-element check agrees; branch accuracy, meaning agreement of the buckling pattern with finite elements; the fraction of runs that end in unphysical minima; optimizer iterations and wall-clock time; and the distance of visited boundary states from the surrogate's training distribution.

The decisive check is the slender-column family. A purely local pipeline should often find local pore patterns or fail to converge there. If our method recovers the global mode in most runs, keeps 8×8 errors no worse than CES with DAGGER at fewer finite-element calls, and keeps error flat from 8×8 to 32×32, then non-locality belongs in the solver and not in the energy. If the coarse-FEA initializer or the message-passing proposer matches it, the contribution shrinks to the training recipe, and we will say so.