betaFeedback

WorksComputer Science

ISLA: A Coordinate-Free, Measure-Weighted Transformer for Boundary-Driven PDEs

Abstract

A foundational principle of physics is that all coordinate systems are equally valid: the behavior of a PDE-governed system does not depend on the origin or orientation of the frame, nor on the units or mesh used to write it down, and neither should a surrogate model. Yet the neural surrogates with the lowest errors on today's aerodynamics benchmarks lack these invariances and fail under simple transformations of the same problem: for models trained on PDEs of cars in one pose (i.e., translation and rotation) and from one mesher, rotating the full PDE raises the surface-pressure error from 4% to more than 100%, and re-sampling its boundary raises it to about 30%. We introduce ISLA (Invariant Slice Attention), a slice-attention transformer for steady, boundary-driven PDEs in which no learned operation receives a coordinate and every sum over the boundary is a quadrature. Positions enter only as distances and relative angles to learned slice anchors, lengths are measured in a unit computed from the boundary, and interior points query the boundary through a tree-accelerated learned kernel without influencing one another. With every boundary cell a token and an exact boundary read, ISLA is equivariant to rigid motions and reflections, invariant to the units of its declared data, and consistent under mesh refinement, while at every setting each query is independent of all other queries. On AeroZoo, 2,816 flows that vary in shape, size, speed, and boundary conditions, its mean reference-scaled velocity and pressure errors are at least 3.1 and 3.3 times lower than any baseline's. On AirfRANS its errors are second only to those of a boundary-integral model (GLOBE) and at least 1.6 times lower than those of Transolver and GeoTransolver.

Introduction

Neural surrogates now predict the flow around a car in seconds, with errors of a few percent of the reference simulation [5, 3] (Wu et al. 2024). The models with the lowest errors on aerodynamics benchmarks are transformers that make global attention affordable on meshes of 10510^5 to 10810^8 points, often by routing points through a small set of learned slices, which are soft groups of points [60, 99] (Wu et al. 2024).

A boundary-value problem is a physical statement: a boundary, the conditions imposed on it, and the properties of the medium. Writing it down for a computer takes choices that are not part of the physics: an origin and axes, units, a mesh of the boundary, the cells of that mesh that are kept, and the points at which the solution is requested. We call these choices the presentation of the problem, and the solution does not depend on them. The surrogates with the lowest errors on today’s benchmarks do Figure 1, because the presentation is their input: coordinates enter as features, and sums over points ignore the area that each point represents. Transolver and GeoTransolver also pool interior query points into the shared slices, so a prediction at one point changes when other points are queried (a coupling that anchor-based cross-attention models such as AB-UPT avoid; [5]). For tuned benchmark networks of Transolver and GeoTransolver, trained on DrivAerML [8] as stored, rotating its validation PDE problems at random raises the surface-pressure error from 4% to more than 100% (worse than predicting zero), and uniform area sampling raises it to about 30%.

Figure 1. ISLA’s error does not depend on how a problem is presented. Top: the reference surface pressure coefficient cpc_p on a DrivAerML evaluation case in three presentations: as stored, with the full PDE problem rotated by 170∘170^\circ and translated, and with surface cells drawn by area (dots: subset of cells given; insets: rear wheel). Below: each model’s error in the car’s own frame, with its relative L2L^2 error on this case. Both models were trained without augmentation (GeoTransolver: width 256, Section C.3); the text quotes tuned DrivAerML ensemble members over 34 validation cases (Table 21).

This dependence limits practical use. A training set fixes one convention: every car points along +x+x, in meters, from one mesher. A model that depends on the convention fails when the same problem is written in another frame, sampled by another rule, or stated in other units, and rotation augmentation multiplies the stored-case errors of Transolver and GeoTransolver by 1.04 and 1.03 (§ 5.2). On AeroZoo [81], where every case has its own pose (i.e., translation and rotation), size, speed, and boundary conditions, GeoTransolver needs boundary-condition tokens and per-case scales, both added by hand, to improve on predicting the inlet state everywhere.

Exact symmetry can be built into an architecture layer by layer, but at a cost in training time or accuracy. Layerwise equivariant networks constrain every linear map and nonlinearity ([91, 21, 35, 53, 22, 84]), and AB-GATr, an equivariant transformer on a subset of the points, takes two to eleven times as long to train as its non-equivariant counterpart ([73]). GLOBE ([80]), a boundary-integral architecture, is equivariant and independent of units, and it uses the boundary measure. It has the lowest errors on two-dimensional airfoil flows, and higher errors than slice transformers on three-dimensional automotive flows. We ask whether the accuracy and linear cost of slice attention can be had together with exact independence of the frame, the units, and the query set, and with consistency under remeshing.

ISLA (Invariant Slice Attention) follows three rules, one for each part of the presentation. (i) No learned operation receives a coordinate. Each slice has an anchor, the mean position and mean normal of its tokens (boundary cells) weighted by measure,1 and a token’s position enters the network only as distances and relative angles to the anchors. Lengths are measured in a unit computed from the boundary, and vectors are assembled at the output from directions that rotate with the body. (ii) Every sum over the boundary is a quadrature. Cell measures weight every attention over boundary tokens, so a mesh changes a prediction only by a quadrature error. (iii) Interior points are read-only, to give query independence. A point in the domain receives its exact distance and direction to the boundary, and attends to the slices and, through a tree-accelerated learned kernel, to every boundary token; because it contributes to no sum, the prediction there depends on the point and the boundary alone.

Contributions. First, we introduce ISLA (Section 3), to our knowledge the first slice-attention surrogate that is exactly equivariant to the Euclidean group. Second, we prove its invariances (§ 4) and show that measure-weighted slice attention is a ratio of two quadratures, so that with every cell a token its outputs converge under refinement. Third, we show (§ 5) that ISLA’s errors are the lowest on AeroZoo, second only to a boundary-integral model (GLOBE) on AirfRANS, and changed by at most 1.1% by a change of presentation. An open-source implementation of ISLA will be available in NVIDIA PhysicsNeMo ([67]) at https://github.com/NVIDIA/physicsnemo.

What a Solution Cannot Depend On

Setting. We consider steady boundary-value problems on a domain Ω⊂Rd\Omega\subset\mathbb{R}^{d} whose boundary is a union of pieces, Γ=⋃bΓb\Gamma= \bigcup_b \Gamma_b, one per boundary condition:

F(u,∇≤ku;μ)=0in Ω,Bb(u,∇≤k−1u)=gbon Γb.(1)\begin{aligned} \mathcal{F}(u,\nabla^{\leq k}u;\mu)&=0 &&\text{in }\Omega,\\ \mathcal{B}_b(u,\nabla^{\leq k-1}u)&=g_b &&\text{on }\Gamma_b. \tag*{(1)} \end{aligned}

Here uu collects the unknown fields and ∇≤ku\nabla^{\leq k}u its spatial partial derivatives up to order kk (including divergence, curl, strain rate, and Laplacian), gbg_b is condition bb’s prescribed data, and μ\mu holds material constants and any vector attached to no finite boundary, such as an asymptotic far-field velocity as ∥x∥→∞\lVert x\rVert\to\infty on an unbounded domain (a Dirichlet state at a finite outer boundary enters through gbg_b on that boundary). Given the posed problem P={(Γb,gb)b,μ}P = \{(\Gamma_b, g_b)_b, \mu\} alone, a surrogate approximates S:P↦uS : P \mapsto u from examples.

A linear model problem. For a linear problem with constant coefficients, the field at an interior point is an integral over the boundary, u(x)=∫ΓG(x−y) ψ(y) dSyu(x) = \int_{\Gamma} G(x-y)\,\psi(y)\,\mathrm{d}S_y, of a density ψ\psi that the boundary data determine [41, 70, 62, 52]. The formula has three features: every boundary point influences every field point, its influence is weighted by the surface measure, and it depends on relative positions alone. ISLA keeps all three and does not assume linearity.

Presentations. A model receives a presentation of PP: the coordinates of Γ\Gamma in some frame and units, a mesh of Γ\Gamma or a sample of one, and a list of points at which uu is requested. Infinitely many presentations describe one problem. If the problems of interest are closed under rigid motions, reflections, and changes of units, each with one solution, and the equations hold in every frame and system of units (Assumption 1), then the solution operator (i) is covariant under rigid motions and reflections, (ii) rescales each output by the factor that its units dictate, and (iii) depends on Γ\Gamma as an oriented surface, and not on how Γ\Gamma is meshed or sampled, on the order of its cells, or on the other query points (Proposition 1, stated and proved in Section A).

The proof uses nothing about the form of F\mathcal{F}. We call a surrogate presentation-independent if it satisfies exactly (i), (ii), and the parts of (iii) that concern the order of the cells and the query set. We call it consistent if its dependence on the mesh and sample vanishes under refinement [82, 77]; ISLA is both under § 4.

The ISLA Architecture

ISLA keeps what makes slice attention effective: a learned soft partition through which every token exchanges information with every other at linear cost. It changes what the network receives and how it sums. Figure 2 follows one block from boundary cells to outputs on an airfoil, and Figure 3 shows the slices of a trained model on a car (pseudocode in Section B).

Figure 2. One block of ISLA, piece by piece, on an airfoil with 96 cells and six slices (hand-made scores). (a) A token is a cell with a centroid, a normal, and a measure; lengths are in units of LL. (b) The routing weights αis0\alpha_{is}^{0}, a softmax over tokens with the measure (αis0\alpha_{is}^{0} is the same with the refined scores λis′\lambda'_{is}): each short leading-edge cell gets a small weight; colors show each cell’s highest-scoring slice. (c) Each slice’s anchor (star and arrow) and the six scalars (K=1K = 1) that relate one token to one anchor. (d) The slice states ZsZ_s of one channel (squares), the read-back weights ωis\omega_{is}, a softmax over slices, and the read-back (black). (e) A vector output in two poses, with the same coefficients. (f) A query point’s distance and direction to the boundary, and the BVH clusters and tokens of its boundary read at θ=1\theta= 1.

Figure 3. The slices of a trained ISLA on one DrivAerML case. (a) Each surface token colored by its dominant slice, the slice with the largest read-back weight ωis\omega_{is}, in layers 3, 6, and 12, with the number of dominant slices; pale tints only separate slices and are unrelated between layers; the three saturated colors of layer 6 are the slices of (b). (b) The three slices of layer 6 dominant at the most tokens, with their area and token shares (finer mesh there): ωis\omega_{is} from the side and below, with routing anchor (star) and mean normal (arrow). On this nearly symmetric car, each slice’s weights are nearly left–right symmetric as well.

Tokens with a Measure and a Scale

Inputs. A case is one mesh per boundary condition (an inlet, an outlet, a no-slip wall). A token is a cell ii with its centroid xix_i, its unit normal n^i\hat{n}_i, its measure aia_i (area for 2D boundaries, or length for 1D boundaries), and any data

that its condition prescribes. The global data are KK unit directions g^k\hat{g}_k and scalars σ\sigma. A surface task asks for fields on the cells of a boundary, and an interior task for fields at query points xqx_q in the domain (§ 3.4). A token’s first state is computed from invariants only (the cosines n^i⋅g^k\hat{n}_i \cdot\hat{g}_k, norms and inner products of its condition’s data, and σ\sigma) by a per-condition layer; all later layers are shared (Figure 2a).

An intrinsic unit of length. Coordinates enter only after division by a length that the boundary itself defines, the root-mean-square distance between two points of the surface,

L2=1A2∬ΓΓ∥x−y∥2 dSx dSy,A=∫ΓdS,(2)L^2 = \frac{1}{A^2}\iint_{\Gamma\Gamma} \lVert x-y\rVert^2\,\mathrm{d}S_x\,\mathrm{d}S_y,\qquad A = \int_{\Gamma}\mathrm{d}S, \tag*{(2)}

evaluated exactly for the meshed surface in O(N)O(N) operations. LL needs no origin, is unchanged when a cell is split, and scales with the geometry. A problem may declare which of its data define other scales, such as a speed UU from the inlet and the fluid’s density. Every dimensional input is divided by its scales and every output multiplied by its own (a pressure by the density times U2U^2). By the Buckingham Π\Pi theorem [25, 11], physical laws relate dimensionless groups alone; feeding only dimensionless numbers lets the network apply arbitrary nonlinear maps without breaking unit invariance. We write ri=xi/Lr_i = x_i/L.

Measure weights. Each token has a weight wiw_i, the surface measure that it represents: wi=aiw_i = a_i when every cell is a token. When the boundary has more cells than a budget of BB tokens (a car has 10710^7; we use B=2×105B = 2 \times10^5), a cell kept with probability πi\pi_i has the Horvitz–Thompson weight wi=ai/πiw_i = a_i/\pi_i [43]. On interior tasks the model draws the sample itself, with πi∝ai\pi_i \propto a_i, systematically along a space-filling curve [61, 83]. On surface tasks the data pipeline draws cells uniformly. Each condition is normalized by its own measure AbA_b and given a learned log share βb\beta_b, so that a far-field boundary’s share of every sum does not grow with its truncation radius. With wˉi=eβb(i)wi/Ab(i)\bar{w}_i = e^{\beta_{b(i)}} w_i/A_{b(i)} (wˉi=wi\bar{w}_i = w_i with one declared condition), every softmax over tokens is

softmax⁡i(λi)=wˉieλi∑jwˉjeλj,(3)\operatorname{softmax}_{i}(\lambda_i) = \frac{\bar{w}_i e^{\lambda_i}}{\sum_j \bar{w}_j e^{\lambda_j}}, \tag*{(3)}

that is, the measure enters as a bias log⁡wˉi\log\bar{w}_i on the score [17, 95]. A sum ∑isoftmax⁡i(λi)fi\sum_i \operatorname{softmax}_i(\lambda_i) f_i is then a Nadaraya–Watson ratio of two quadratures [64, 90], of the same two surface integrals for every mesh. A short cell near a leading edge stands for little surface, so it carries little weight (Figure 2b), whatever the density of the mesher.

The Invariant Slice Block

A block updates the token states hi∈RC\mathbf{h}_i \in\mathbb{R}^{C} in four steps (Figure 2b–Figure 2d), with h~i=LN⁡(hi)\tilde{\mathbf{h}}_i = \operatorname{LN}(\mathbf{h}_i) a layer normalization over the CC channels.

Route. Each of MM slices has a prototype ps∈RC\mathbf{p}_s \in\mathbb{R}^{C}, a learned vector plus a measure-weighted attention pooling of the case’s tokens (Section B.3). A token is scored by a scaled cosine similarity, λis=τh~i⋅ps/(∥h~i∥∥ps∥)\lambda_{is} = \tau\tilde{\mathbf{h}}_i \cdot\mathbf{p}_s / (\lVert\tilde{\mathbf{h}}_i\rVert\lVert\mathbf{p}_s\rVert), and routed by αis0=softmax⁡wˉi(λis)\alpha_{is}^{0} = \operatorname{softmax}_{\bar{w}^{i}}(\lambda_{is}), a softmax over the tokens. Each slice spreads one unit of weight over the boundary, in proportion to the surface that each token represents, so a slice is a quadrature average over a soft subset.

Anchor. From the same weights each slice forms its anchor, a position and a facing direction,

rˉs=∑iαis0ri,ms=∑iαis0n^i∥∑iαis0n^i∥.(4)\bar{\mathbf{r}}_s = \sum_i \alpha_{is}^{0}\mathbf{r}_i,\qquad \mathbf{m}_s = \frac{\sum_i \alpha_{is}^{0}\hat{\mathbf{n}}_i}{\left\lVert\sum_i \alpha_{is}^{0}\hat{\mathbf{n}}_i\right\rVert}. \tag*{(4)}

Both are weighted means of vectors that move with the body, with weights that do not change, so the anchors move with the body and give each layer MM adaptive reference points (stars in Figure 2c).

Relate. With ρis=ri−rˉs\boldsymbol{\rho}_{is} = \mathbf{r}_i - \bar{\mathbf{r}}_s and ρ^is\hat{\boldsymbol{\rho}}_{is} its direction, 5+K5 + K scalars relate token ii to anchor ss,

ξis=[∥ρis∥, log⁡∥ρis∥, ρ^is⋅g^k,\boldsymbol{\xi}_{is} = \left[ \lVert\boldsymbol{\rho}_{is}\rVert,\ \log\lVert\boldsymbol{\rho}_{is}\rVert,\ \hat{\boldsymbol{\rho}}_{is}\cdot\hat{\mathbf{g}}_k, \right.
ρ^is⋅n^i, ρ^is⋅ms, n^i⋅ms].(5)\left. \hat{\boldsymbol{\rho}}_{is}\cdot\hat{\mathbf{n}}_i,\ \hat{\boldsymbol{\rho}}_{is}\cdot\mathbf{m}_s,\ \hat{\mathbf{n}}_i\cdot\mathbf{m}_s \right]. \tag*{(5)}

how far the anchor is, whether it lies along each global direction, whether the token and the anchor each lie in front of the other’s face, and whether the two faces agree. Each scalar is a norm or an inner product of vectors that rotate together, so it is unchanged by every rotation, reflection, and translation. These scalars are the only positional information that a boundary token receives (Figure 2c). A linear map of them refines the routing, λis′=λis+wξ⋅ξis\lambda'_{is} = \lambda_{is} + \mathbf{w}_{\xi}\cdot\boldsymbol{\xi}_{is}.

Mix and read back. The refined scores give αis=softmax⁡wˉi(λis′)\alpha_{is} = \operatorname{softmax}_{\bar{w}^{i}}(\lambda'_{is}) over tokens, which forms the slice states, and ωis=softmax⁡s(λis′)\omega_{is} = \operatorname{softmax}_{s}(\lambda'_{is}) over slices (unweighted, since slices have no measure), which returns them to the tokens. With biases omitted,

Zs=∑iαish~i,Z_s = \sum_i \alpha_{is}\tilde{\mathbf{h}}_i,
Zs←Zs+MLP⁡slice(LN⁡(Zs)),(6)Z_s \leftarrow Z_s + \operatorname{MLP}_{\mathrm{slice}}(\operatorname{LN}(Z_s)), \tag*{(6)}
hi←hi+Wr[h~i; ∑sωisZs; Wf∑sωisξis],(7)\mathbf{h}_i \leftarrow\mathbf{h}_i + W_r\left[\tilde{\mathbf{h}}_i;\ \sum_s \omega_{is}Z_s;\ W_f\sum_s \omega_{is}\boldsymbol{\xi}_{is}\right], \tag*{(7)}

followed by a token MLP; the last entry is the token’s mean relation to the slices it reads. The refined scores are thus normalized twice (as in Figure 2b and d): over tokens with the measure, so that a slice state is a quadrature average of its tokens, and over slices without it, so that each token reads a convex mixture of slice states. Transolver normalizes once, over slices, and pools by soft counts, so its slice states weight every point equally, whatever surface it represents. ISLA has no attention among slices; Transolver does not need its own [92] (Hu et al. 2026). A slice state reaches the rest of the body through the tokens that read it, at the next block’s routing. In a trained model the partition refines with depth (Figure 3a): a few slices share the car in a shallow layer and almost all of the M=128M = 128 in the last one, while single slices pick out regions such as the rear wheels and the floor between them (Figure 3b); consistent with reflection equivariance (Theorem 1), their weights are nearly left–right symmetric on this nearly symmetric car. The cost is O(NC2+NMC)O(NC^2 + NMC) per block: linear in the number of tokens, with no pairwise term.

Outputs of Any Tensor Rank

The states are invariant, so a vector or tensor output is assembled at the end, from invariant coefficients and the token’s own directions [98, 55, 87]:

Yi=∑j1…jrci,j1…jr dij1⊗⋯⊗dijr(8)Y_i = \sum_{j_1\ldots j_r} c_{i,j_1\ldots j_r}\,\mathbf{d}_{ij_1} \otimes\cdots\otimes\mathbf{d}_{ij_r} \tag*{(8)}

plus isotropic terms, with ci=WhLN⁡(hi)+bh\mathbf{c}_i = W_h \operatorname{LN}(\mathbf{h}_i) + \mathbf{b}_h and basis vectors dij\mathbf{d}_{ij} built from the global directions g^k\hat{\mathbf{g}}_k, the normal n^i\hat{\mathbf{n}}_i, and the direction u^i\hat{\mathbf{u}}_i to the token from its soft anchor, a mixture of anchors under one more routing (Section B.5). A pressure is one coefficient, and a wall shear stress combines the basis vectors (Figure 2e).

Read-Only Interior Points

A query point xq\mathbf{x}_q in the domain has no normal and no measure (Figure 2f). The interior form of ISLA gives it two geometric quantities, computed inside the model from the full-resolution surface. The first is its signed distance dˉq\bar{d}_q to the boundary, from an exact closest-point search whose sign comes from the generalized winding number [45, 12]. The second is the direction v^q\hat{\mathbf{v}}_q in which that distance increases, which replaces the normal in every invariant.

With no measure (wˉq=0)(\bar{w}_q = 0), a query enters no sum over tokens. At each layer it performs the read-back of (7) with the boundary’s slice states, and it attends to every boundary token jj directly, as in a boundary-integral method:

hq←hq+Wo∑jsoftmax⁡jwˉ(κ(ℓqj)+⟨qq,kj⟩)vj(9)\mathbf{h}_q \leftarrow\mathbf{h}_q + W^{o} \sum_j \operatorname{softmax}_{j}^{\bar{w}}\bigl(\kappa(\ell_{qj}) + \langle\mathbf{q}_q,\mathbf{k}_j\rangle\bigr)\mathbf{v}_j \tag*{(9)}

for one head and without biases and layer normalizations (Algorithm 1), where kj\mathbf{k}_j and vj\mathbf{v}_j are keys and values of the boundary states and qq\mathbf{q}_q is the query vector of hq\mathbf{h}_q, scaled by 1/ck1/\sqrt{c_k} for its ckc_k channels. κ\kappa is a learned kernel of the pair’s invariants ℓqj\ell_{qj}: a distance in units of LL, its logarithm, the logarithm of its ratio to ∣dˉq∣|\bar{d}_q|, and cosines (Section B.7). A tree makes this boundary read affordable, as in GLOBE (Sharpe,

  1. and panel-clustering and NN-body codes (Rokhlin, [72]; Barnes & Hut [13]; Hackbusch [38]): a distant cluster enters as one virtual token, with the measure-weighted means of its members, when its size is below θ\theta times its distance and its normals agree, where θ\theta is the tree’s opening angle. We use θ=1\theta= 1, about 680 sources per query in place of 2×1052 \times10^{5}. At θ=0\theta= 0 the read is exact.

Since queries contribute to no sum, the boundary side runs once per case, and a prediction at xq\mathbf{x}_q is a function of xq\mathbf{x}_q and the boundary alone, so large fields are evaluated in chunks.

Configuration. We use one configuration on every dataset: width C=512C = 512, 12 blocks, and M=128M = 128 slices, with 66.3 M parameters (67.5 M for the interior form).

Guarantees

The three rules make ISLA presentation-independent (§ 2) at every valid parameter value and consistent under remeshing (proofs in Section A).

Theorem 1 (Exact invariances). In exact arithmetic, with every boundary cell a token and no cell’s weight below 10−1210^{-12} of the case’s total measure, the outputs of ISLA are (i) equivariant under rotations, reflections, and translations of the cells, their normals and data, the global directions, and the query points; (ii) multiplied by the factors of their units before target standardization, with unchanged internal states, under a rescaling of all lengths and of the units of the declared scales, at fixed data without declared units; (iii) unchanged by a permutation of the cells, by a common rescaling of the measures given with them, and by replacing a cell with coincident copies that share its measure; and (iv) at each query point, independent of the other query points; this clause needs neither hypothesis and holds for every θ≥0\theta\ge0 and every fixed draw of tokens. For the interior form, (i) to (iii) hold with the exact boundary read (θ=0\theta= 0) when the boundaries form a closed surface, at every query point that has a unique closest point on it.

The proof is an induction over the layers: a measure-weighted softmax of invariant scores has invariant weights that sum to one, so the anchors of Equation (4) are equivariant, the relations of Equation (5) are invariant, and so is the next state. Under these hypotheses, clause (i) holds for symmetric bodies as well. Clause (ii) matches Proposition 1(ii) when every dimensional constant is a declared scale or enters a global scalar; without a Reynolds number, ISLA predicts one dimensionless field at all sizes.

Consistency. For remeshing the statement is weaker, convergence in place of invariance (Proposition 2, Section A). Along meshes that refine a surface with cell normals that converge to its own, every measure-weighted sum in ISLA converges to a ratio of surface integrals. With every cell a token, θ=0\theta= 0, and no weight floor, the outputs converge to a mesh-independent limit; without the measure, the limit follows the mesher’s density.

Approximations. Large interior cases use two approximations outside the theorem: a draw of 2×1052 \times10^{5} tokens from 10710^{7} cells and three at θ=1\theta= 1, both ordered along a principal-axis curve that can tie on symmetric boundaries (Section A). In float32 a rigid motion moves the predicted velocity on DrivAerML by 6×10−36 \times10^{-3}, below another draw’s 1.4×10−21.4 \times10^{-2} (Section D.5).

Experiments

Setup. AeroZoo (Sharpe et al., [81]) contains 3,815 time-averaged RANS solutions, each with its own geometry, in eight enclosure configurations, at Reynolds numbers from 10310^{3} to 10810^{8}; we use the 2,816 whose averages are converged. AirFRANS (Bonnet et al., [18]) contains RANS solutions of airfoil flows, and DrivAerML (Ashton et al., [8]), WindsoRML (Ashton et al., [6]), and AhmedML (Ashton et al., [7]) time-averaged scale-resolving simulations of flows around road vehicles; on these four we use the splits of FluidsBench (FluidisBench, [32]). We compare ISLA with Transolver (Wu et al., 2024) and GeoTransolver (Adams et al., [3]), and on AirFRANS and the automotive datasets also with GLOBE (Section C).

AeroZoo

AeroZoo varies every part of a problem’s presentation at once: geometry, size, speed, pose, and boundary-condition layout (Figure 4 and Table 1; medians in Table 8).

ModelεU\varepsilon_UεUnear\varepsilon_U^{\mathrm{near}}εp\varepsilon_prUr_Urpr_pεU<ref.\varepsilon_U < \mathrm{ref.}
Free-stream reference0.4400.4421.8090.3891.000—
Zero predictor1.2031.1931.8091.0001.000—
Transolver, SI units1.2021.1931.8100.9991.0091%
Transolver, scaled0.6170.6211.4190.5392.19241%
GeoTransolver, SI units1.1841.1801.8110.9811.0151%
GeoTransolver, scaled0.8980.8991.8390.7531.93513%
GeoTransolver + BC, SI units0.4750.4791.8090.4011.00220%
GeoTransolver + BC, scaled0.2940.3061.2920.2570.83882%
ISLA0.0820.1140.2980.1120.31598%
ISLA + boundary targets0.0780.1100.1710.1070.28998%

Table 1. Table 1. AeroZoo, full.: means over 515 test cases (bold: best per column). εU\varepsilon_U, εUnear\varepsilon_U^{\mathrm{near}} (within 1 Lref1\,L_{\mathrm{ref}} of body), and εp\varepsilon_p: reference-scaled; rUr_U, rpr_p: relative L2L^2; “εU<ref.\varepsilon_U < \mathrm{ref.}”: share of cases with εU\varepsilon_U below the reference’s; “BC”: boundary tokens; “scaled”: per-case scales; last row adds boundary targets (Table 8).

Figure 4. On AeroZoo, ISLA has the lowest velocity error in every enclosure configuration. Top: one median-error test case per configuration: reference velocity magnitude on a plane through the body and one ISLA model’s prediction (duct: around its contraction). Bottom: median εU\varepsilon_U by configuration on in-distribution test cases; ISLA’s is 1.3–7.8× below the best baseline’s.

Table 8. AeroZoo, full split (515 canonical test cases; lower is better). “BC”: with tokens that carry the boundary conditions; without them a baseline has no input for the inlet conditions. The two indented rows are the other settings of the row above them. “Med. εU÷\varepsilon_U \div ref.” is the median over cases of a model’s εU\varepsilon_U divided by the free-stream reference’s, and “Share εU<\varepsilon_U < ref.” is the share of cases on which the model’s εU\varepsilon_U is lower. Baseline rows are from Sharpe et al. [81] (one seed each); both ISLA rows average 4 seeds, and “ISLA + boundary targets” also supervises boundary targets in training (Section C.2). Bold: the best value in each column. Dash: no value.

ModelUnitsParametersRef.-scaled εU↓\varepsilon_U \downarrow medianRef.-scaled εU↓\varepsilon_U \downarrow meanRef.-scaled εp↓\varepsilon_p \downarrow medianRef.-scaled εp↓\varepsilon_p \downarrow meanMed. εU↓÷\varepsilon_U \downarrow\div ref.Share εU↑<\varepsilon_U \uparrow< ref.
Free-stream reference––0.1100.4400.0591.809––
Zero predictor––1.0051.2030.0591.809––
TransolverSI units9.0 M1.0071.2020.0591.8109.191%
Transolverper-case scales9.0 M0.3450.6170.0561.4191.1541%
GeoTransolverSI units27.6 M1.0041.1840.0621.8118.881%
GeoTransolverper-case scales27.6 M0.7690.8980.0811.8393.9013%
GeoTransolver + BCSI units27.6 M0.1730.4750.0591.8091.1220%
GeoTransolver + BCper-case scales27.6 M0.0840.2940.0471.2920.8482%
float32, step scheduleper-case scales27.6 M0.0960.2770.0471.1600.8480%
bfloat16, step scheduleper-case scales27.6 M0.1010.2530.0500.9870.8676%
ISLAcomputed from the boundary67.5 M0.0530.0820.0230.2980.5098%
ISLA + boundary targetscomputed from the boundary67.5 M0.0520.0780.0210.1710.4798%

Table 8.

First, Transolver and GeoTransolver as released have no input for the inlet conditions, and in SI units their velocity errors are within 2% of predicting zero (rU=0.999r_U = 0.999 and 0.981). Second, with tokens that carry the boundary conditions (BC), GeoTransolver in SI units still has a higher mean εU\varepsilon_U than the free-stream reference, which predicts the inlet state everywhere (0.475 and 0.440; rp=1.002r_p = 1.002), on cases whose sizes span a factor of 10310^3 and speeds 200. With per-case scales as well, it reaches εU=0.294\varepsilon_U = 0.294 (rU=0.257r_U = 0.257, rp=0.838r_p = 0.838) and has a lower error than the reference on 82% of the cases. Third, ISLA reaches εU=0.082\varepsilon_U = 0.082 (rU=0.112r_U = 0.112), εp=0.298\varepsilon_p = 0.298 (rp=0.315r_p = 0.315), and 98%: its mean εU\varepsilon_U and εp\varepsilon_p are at least 3.1 and 3.3 times lower than any baseline’s in any setting (Table 8). The baselines are single seeds from Sharpe et al. [81] (9.0 and 27.6 M parameters; ISLA averages 4 seeds), and size does not explain the margin: on the same step schedule, a 28.2 M ISLA with half the boundary tokens has mean εU\varepsilon_U 3% above a 67.5 M one (Table 12). Supervising boundary targets too (1.46× step time) lowers εp\varepsilon_p to 0.171 (rp=0.289r_p = 0.289) and εU\varepsilon_U to 0.078 (rU=0.107r_U = 0.107).

ISLA, step scheduleParametersRef.-scaled εU\varepsilon_U ↓\downarrow medianRef.-scaled εU\varepsilon_U ↓\downarrow meanRef.-scaled εp\varepsilon_p ↓\downarrow medianRef.-scaled εp\varepsilon_p ↓\downarrow meanMed. εU\varepsilon_U ↓\downarrow ÷\div ref.Share εU\varepsilon_U ↑\uparrow < ref.
12 blocks, 128 slices67.5 M0.0540.0830.0220.3210.4998%
8 blocks, 64 slices28.2 M0.0540.0850.0220.3160.4998%

Table 12. An ISLA of 28.2 M parameters against one of 67.5 M on AeroZoo’s full split (515 canonical test cases), both trained on the same step schedule, 2 seeds each. The smaller model also uses half the MLP width and half the boundary tokens per case. Columns as in Table 8.

Held-out families and layouts. With a geometry family held out of training (blobs, or CAD parts), ISLA’s median εU\varepsilon_U on cases with a body is 0.059 and 0.079 (reference: 0.099 and 0.138). With Reynolds numbers above 10610^6 held out it is 0.067, close to the reference’s 0.076. With the crossflow or dual-inlet layout held out, it is only 31% and 11% below the reference’s, and with non-box enclosures held out it exceeds the reference’s (Table 11): presentation independence does not extrapolate to unseen topologies.

Table 11. ISLA on AeroZoo: the full split and six splits that hold a region out of training, with the free-stream reference on the same canonical test cases (mean of 4 seeds on full, 2 on the other splits). “Med. εU÷\varepsilon_U \div ref.” and “Share << ref.” are as in Table 8. The two splits that hold out a geometry family are scored on cases with a body.

SplitHeld out of trainingCases trainCases testISLA Ref. εU↓\varepsilon_U \downarrow medianISLA Ref. εU↓\varepsilon_U \downarrow meanISLA Ref. εp↓\varepsilon_p \downarrow medianISLA Ref. εp↓\varepsilon_p \downarrow meanISLA Med. εU↓÷\varepsilon_U \downarrow\div ref.ISLA Share ↑<\uparrow< ref.Free-stream reference Ref. εU↓\varepsilon_U \downarrow medianFree-stream reference Ref. εU↓\varepsilon_U \downarrow meanFree-stream reference Ref. εp↓\varepsilon_p \downarrow medianFree-stream reference Ref. εp↓\varepsilon_p \downarrow mean
fullnothing2,0115150.0530.0820.0230.2980.5098%0.1100.4400.0591.809
bank_blobsblob bodies1,6628720.0590.0850.0240.2940.6199%0.0990.4090.0601.655
bank_zero_to_cadCAD-part bodies2,2502240.0790.1170.0410.3620.5999%0.1380.4660.0832.004
reynoldsRe≥106Re \ge10^61,5771,0010.0670.1250.0300.5760.7582%0.0760.3790.0461.640
family_non_boxnon-box enclosures1,8506920.1030.2570.1340.7471.3723%0.0750.2380.0390.595
profile_crossflowcrossflow layout2,2981730.6140.6562.3412.9060.7297%0.8860.9472.6243.490
profile_dual_inletdual-inlet layout2,0444591.3971.4506.7808.3790.8897%1.5631.6597.1509.134

Table 11.

Pose and Discretization Tests

We give each trained model the same evaluation problems in another presentation and measure its error again, on 8 tasks (Figure 8 in Section D): AirfRANS, DrivAerML, HiLiftAeroML (Ashton et al., [9]), SHIFT-SUV (Lumi-Table 2).

Figure 8. Changing how a problem is presented raises the baselines’ errors and leaves ISLA’s unchanged. Each model’s error on the evaluation cases as stored (open markers) and on the same cases rotated and translated (top) or re-sampled by area (bottom); means over 2 to 4 seeds (Section C.3). The pipelines of the automotive, wing, and DeepJEB++ datasets center each case, so there the top panel tests rotation alone.

nary Cloud, 2025), and three solid-mechanics datasets (Section C). In the pose test, every case is rotated at random and translated by one radius of the body, together with its global directions and vector targets. In the re-sampling test, the surface cells that a model receives are drawn with probability proportional to their area, in place of the mesher’s refinement pattern, and errors are weighted by measure for every model. The models of Figure 8 were trained without augmentation, so the tests isolate invariance.

A rotated case lies outside everything that Transolver and GeoTransolver were trained on, and their errors rise to between 0.8 and 2.0 times that of predicting zero. Re-sampling by area changes only the density of the points that they receive, yet it raises their surface-pressure errors on DrivAerML from 4% to 30 and 14%, and on HiLiftAeroML and SHIFT-SUV to 5 to 18%. ISLA’s error changes by at most 1.1% of its value in every test. On DrivAerML’s 34 validation cases, rotating the full PDE problem multiplies the surface-pressure errors of tuned Transolver and GeoTransolver networks by 26 to 31 and changes ISLA’s by at most 0.2% (Table 21). Moving each case into the vehicle’s principal-axis frame at inference still multiplies the baselines’ errors by 5.8 and 5.4, or by 1.09 and 1.18 after a fixed rotation fitted on the training cases. Augmentation covers only its trained subgroup: vertical-axis augmentation removes the vertical-axis rise (1.001×) while leaving SO(3) at 23× (Table 21), whereas uniform SO(3) augmentation holds rotation changes within 0.2% and multiplies stored-case errors by 1.04 and 1.03 (Table 22).

Table rows:

PresentationTransolver ppTransolver τw\tau_wGeoTransolver ppGeoTransolver τw\tau_wGLOBE ppGLOBE τw\tau_wISLA ppISLA τw\tau_w
As stored4.056.203.925.938.879.673.916.40
Rotated about the vertical axis10511210412511.011.53.916.41
Rotated on SO(3)11011512213011.111.83.916.42
in principal-axis frame23.331.521.228.8––––
in aligned principal-axis frame4.406.914.617.08––––
As stored, on the sample3.916.153.785.888.779.643.786.36
Re-sampled by area, on the sample29.939.233.840.09.3510.63.77*6.35*
Retrained with vertical-axis rotation and translation (1 seed)
As stored4.596.674.826.84––––
Rotated about the vertical axis4.596.664.836.84––––
Rotated on SO(3)10798.1113100––––
Re-sampled by area, on the sample31.441.432.742.8––––

Table 21. Pose and discretization tests on DrivAerML’s validation cases: relative L2L^2 error in percent of one network of each family’s DrivAerML full entry, averaged over the 34 validation cases of that split (pp: surface pressure; τw\tau_w: wall shear stress). Top block: no network was trained with rotations or translations. In each rotated row each case has one pose, the same for every model; every pipeline centers the case, so the translation reaches no model. The first five rows are scored on every cell of the stored mesh (the two indented rows apply the vehicle’s principal-axis canonical frame at inference, without and with a fixed alignment rotation fitted on the training cases), and the last two on one sample of about 10610^6 cells per case drawn in proportion to area, with Horvitz–Thompson weights, the same cells for every model. *: ISLA’s network here is its interior form, a joint surface and volume network, which draws its own tokens in proportion to area (Section B.2), so for it the last row is a second draw of the same law and not a change of law. The networks of Transolver, GeoTransolver, and GLOBE are at the checkpoints of their entries, chosen on these cases; ISLA’s is its final checkpoint.

ModelSeedsSurface pressure (rel. L2L^2) ↓ Stored [%]Surface pressure (rel. L2L^2) ↓ Rotated [%]Surface pressure (rel. L2L^2) ↓ Rot. ÷ st.Wall shear stress (rel. L2L^2) ↓ Stored [%]Wall shear stress (rel. L2L^2) ↓ Rotated [%]Wall shear stress (rel. L2L^2) ↓ Rot. ÷ st.
Transolver44.13118296.6714121
Transolver, trained on rotations24.324.321.0016.996.991.001
GeoTransolver44.00123316.5513320
GeoTransolver, trained on rotations24.134.141.0026.756.740.999
ISLA44.024.021.0006.486.481.000

Table 22. Rotation augmentation on the DrivAerML surface task of the pose and discretization tests: relative L2L^2 error in percent on the evaluation cases as stored and rotated, and the ratio of the two (geometric mean over seeds). The two augmented models are trained on rotations drawn uniformly over all orientations, the law of the rotated test; the other models are trained on cases as stored.

AirfRANS

Each family’s entry is an ensemble on FluidsBench’s splits (FluidsBench, [32]; Section C). GLOBE (learned boundary kernels) has the lowest error in every field (Table 2); ISLA’s are 1.0–2.0× GLOBE’s and at least 1.6× below Transolver’s and GeoTransolver’s. On aoa_extrapolation (test angles outside training), every family’s errors grow by 4–15× from validation to test, and ISLA’s stay at least 2.4× below Transolver’s and GeoTransolver’s.

FieldTransolverGeoTransolverGLOBEISLA
Relative L2L^2 error [%] ↓\downarrow
full (720 training cases), test cases
psp_s1.171.200.340.55
τw\tau_w1.761.460.550.57
u\mathbf{u}0.530.470.150.30
pvp_v1.141.090.280.57
aoa_extrapolation (724 training cases), test cases
psp_s8.319.292.142.58
τw\tau_w6.446.602.142.67
u\mathbf{u}3.843.910.981.37
pvp_v12.2113.023.874.55

Table 2. AirfRANS test cases: relative L2L^2 error in percent (psp_s, τw\tau_w: surface pressure and wall shear; u\mathbf{u}, pvp_v: volume velocity and pressure; bold: lowest in row; Section C).

Automotive Aerodynamics Datasets

We trained and tuned all four model families on the FluidsBench splits of DrivAerML, WindsorML, and AhmedML (FluidsBench, [32]; 3–20 networks per entry; Section C). Because each dataset sweeps one vehicle family in a fixed pose and boundary layout, full-split errors are already near saturation for existing architectures (Sharpe et al., [81]); we report them here for direct comparison with prior work. On the full splits (validation cases on DrivAerML and WindsorML), ISLA’s surface errors lie 12% below to 5% above the lowest other family’s, and its volume errors 7% below to 28% above (Table 14). With 67 training cases (DrivAerML, AhmedML), errors lie 4% below to 13% above; with DrivAerML’s 11 training cases (validation errors; 50,000 steps per network for Transolver, GeoTransolver, and ISLA), ISLA’s errors are 8–13% below the lowest other family’s in all four fields (schedule check in Section D.3).

DatasetSplit (train)CasesRel. L2L^2 error: ISLA ÷ lowest other ↓
DrivAerMLfull (400)val.1.021.051.091.05
scarce (67)val.1.031.041.131.12
super_scarce (11)val.0.870.920.910.91
WindsorMLfull (280)val.0.940.990.950.93
super_scarce (8)val.1.191.240.971.06
AhmedMLfull (400)test0.880.971.281.00
scarce (67)test1.061.061.050.96
super_scarce (11)test1.001.050.931.12

Table 14. Automotive aerodynamics datasets: ISLA’s relative L2L^2 error divided by the lowest of Transolver’s, GeoTransolver’s, and GLOBE’s, for each field (psp_s and τw\tau_w: surface pressure and wall shear stress; u and pvp_v: velocity and pressure in the volume), on test cases, or on validation cases (val.) where not all four families have test results. Bold, below 1: ISLA’s error is the lowest. Every error is in Table 15 to Table 17. On DrivAerML, Transolver (all splits) and GeoTransolver (all splits) use lineups retrained to at least 50,000 steps per network (matching ISLA’s 50,000-step lineups), while GLOBE shows its earlier lineups; on WindsorML, Transolver (all splits), GeoTransolver (all splits), and ISLA (full) use lineups retrained to at least 50,000 steps per network, while the other cells show the earlier lineups.

Ablations and Cost

We remove one rule at a time and retrain (Table 26 in Section D.7; the DrivAerML surface task unless stated). The first two variants keep their accuracy on cases as stored and lose the one invariance that their rule provides. With counts in place of measures, the surface-pressure error on cells re-sampled by area is 11 times higher. With coordinates as inputs, it is about 4% lower on stored cases and 21 times higher on rotated cases. Without anchor relations it is 71% in every presentation; on AirfRANS, dropping the boundary read raises velocity error 10% and lowers eddy-viscosity error 8%, while training at θ=0\theta= 0 (2.7× step time) matches θ=1\theta= 1 within 0.9% (2 seeds).

Table 26. Ablations. Error of a variant divided by the error of ISLA on cases as stored, for cases as stored, rotated, and re-sampled by area (seed means; DrivAerML surface pressure, and AirfRANS velocity for the last three rows). On DrivAerML the reference is the mean of 4 seeds of ISLA. Dash: no value.

VariantRel. L2L^2 error ÷ ISLA (stored)
ISLA1.001.001.00
Counts in place of measures0.990.9911
Coordinates as inputs0.96210.97
No relations to anchors181818
Body alone as the boundary0.980.980.98
ISLA (AirfRANS)1.001.00–
No boundary read1.101.10–
Exact boundary read (θ=0\theta= 0)1.011.01–

Table 26.

ISLA’s cost is linear in the boundary tokens and the query points (Section D.6). One float32 prediction for 2×1052 \times10^{5} surface cells of a car takes 0.37 s on one GPU, between the 9 M GeoTransolver’s and Transolver’s.

Related Work

Slice transformers route mesh points into learned slices (Wu et al., 2024; Luo et al., [60]; Zhou et al., [99]; Adams et al., [3]), while anchor models compress them into a subset (Alkin et al., [4, 5]); AB-UPT and SMART also decouple read-only queries (Alkin et al., [5]; Hagnberger & Niepert, [39]) and Wen & Mishra [92] find slice means stable across same-law subsamples. Where layerwise equivariant networks constrain intermediate features (Thomas et al., [86]; Geiger & Smidt, [35]; Liao & Smidt, [53]; Brehmer et al., [22]; Rygiel et al., [73]), ISLA maps invariant scalars to covariant outputs (Villar et al., [87]; Ling et al., [55]) with anchors like Invariant Slot Attention (Biza et al., [16]). Its log-measure bias adapts proportional attention (Bolya et al., [17]; Yang et al., [95]) per condition with Horvitz–Thompson draws, and its boundary read builds on panel and Green’s-operator methods (Hess & Smith, [41]; Schäfer & Owczarek, [78]; Boullé & Townsend, [19]; Sharpe, [80]) (Section F).

Limitations and Conclusion

Limitations. Presentation independence covers pose, units, and meshing rather than unseen flow topologies: on boundary layouts absent from training, ISLA’s error is near or above the free-stream reference’s (§ 5.1). As a deterministic equivariant map, ISLA cannot represent a single symmetry-breaking mode such as an instantaneous bistable wake (Grandemange et al., [36]), and its length unit (Equation 2) scales with the outer boundary when a far field is truncated (59.5 m with DrivAerML’s tunnel vs. 2 m on the car alone). Three-dimensional interior training uses more than 80 GiB per GPU (Section C.6), and volume-velocity error is 9–13% above tuned GeoTransolver’s on DrivAerML (≥ 67 cases) and 27–30% on full AhmedML.

Conclusion. ISLA has, by construction, the invariances of a boundary-integral model: changing a problem’s presentation moves predictions only by rounding, quadrature, and interior token sampling and tree clustering. It has the lowest errors on AeroZoo and is second only to GLOBE on AirfRANS; on full automotive training sets its surface errors lie 12% below to 5% above the lowest other family’s, and on DrivAerML’s 11-case split 8–13% below them.

Proofs

Throughout, a rigid motion (R,t)(R,t) with R∈O(d)R \in O(d) acts on a posed problem as follows. It moves every point, x↦Rx+tx \mapsto Rx+t. It rotates every vector datum, a↦Raa \mapsto Ra, and every rank-2 datum, T↦RTRTT \mapsto R T R^{\mathsf{T}}, and it leaves scalars unchanged. A pseudotensor takes the further factor det⁡R\det R. Under a reflection (det⁡R=−1\det R=-1) the orientation of the boundary is carried along, so that a cell’s normal maps as a true vector, n^↦Rn^\hat{\mathbf{n}} \mapsto R\hat{\mathbf{n}}. A cell’s normal follows its vertex order, so reflecting the coordinates alone would give −Rn^-R\hat{\mathbf{n}}, which exchanges the two sides of the boundary and poses a different problem.

What the Solution Operator Cannot Depend On

Assumption 1. (a) Well-posedness: the problems of interest form a class that is closed under rigid motions, reflections, and changes of units, and each has exactly one solution. (b) Frame indifference: F\mathcal{F} and the Bb\mathcal{B}_b commute with every rigid motion and reflection that acts on uu, the gbg_b, and μ\mu by tensor type, and every vector, tensor, or dimensional constant that they involve is part of P\mathcal{P}. (c) Dimensional homogeneity: F\mathcal{F} and the Bb\mathcal{B}_b hold in every system of units.

Proposition 1 (What the solution operator cannot depend on). Under Assumption 1, for every posed problem P\mathcal{P}:

(i) Euclidean covariance. For R∈O(d)R \in O(d) and a translation tt acting on the oriented boundary, its data, and the tensors in μ\mu by tensor type, S((R,t)⋅P)(Rx+t)=R⊗rS(P)(x)\mathcal{S}((R,t)\cdot\mathcal{P})(Rx+t)=R^{\otimes r}\mathcal{S}(\mathcal{P})(x) for a rank-rr output (times det⁡R\det R if a pseudotensor).

(ii) Unit covariance. Rewriting P\mathcal{P} in other units rescales each output by the factor that its dimensions dictate.

(iii) Independence of the discretization and of the query set. S(P)(x)\mathcal{S}(\mathcal{P})(x) depends on Γ\Gamma as an oriented surface, and not on how Γ\Gamma is meshed or sampled, on the order of its cells, or on the other query points.

Proof of Proposition 1. (i) Let u=S(P)u=\mathcal{S}(\mathcal{P}), let P′=(R,t)⋅P\mathcal{P}'=(R,t)\cdot\mathcal{P} be the moved problem, with global data μ′\mu', and define u′(x′)=R⊗ru(RT(x′−t))u'(x')=R^{\otimes r}u(R^{\mathsf{T}}(x'-t)) on the moved domain, componentwise for each field of rank rr (with the factor det⁡R\det R for a pseudotensor). By frame indifference, F\mathcal{F} and each Bb\mathcal{B}_b commute with the action of (R,t)(R,t): F(u′,∇≤ku′;μ′)\mathcal{F}(u',\nabla^{\leq k}u';\mu') is the rotated image of F(u,∇≤ku;μ)=0\mathcal{F}(u,\nabla^{\leq k}u;\mu)=0, and Bb(u′,∇≤k−1u′)\mathcal{B}_b(u',\nabla^{\leq k-1}u') is the rotated image of Bb(u,∇≤k−1u)=gb\mathcal{B}_b(u,\nabla^{\leq k-1}u)=g_b, which is the datum of P′\mathcal{P}' on the moved piece Γb\Gamma_b. Hence u′u' solves P′\mathcal{P}', which is again a problem of the class. By well-posedness it is the only solution, so S(P′)=u′\mathcal{S}(\mathcal{P}')=u'. This is the statement that a symmetry of an equation maps solutions to solutions (Olver, [65]).

(ii) A change of units multiplies every quantity qq by ∏jχjej(q)\prod_j \chi_j^{e_j(q)}, where χj>0\chi_j>0 rescales the jj-th base dimension and ej(q)e_j(q) is the exponent of that dimension in qq. By dimensional homogeneity, if uu solves P\mathcal{P} then the rescaled field solves the rescaled problem, and by well-posedness it is that problem’s solution. The Π\Pi theorem (Buckingham, [25]) follows: choosing the χj\chi_j to normalize a maximal set of dimensionally independent data of P\mathcal{P} shows that the dimensionless solution is a function of the remaining dimensionless groups.

(iii) S\mathcal{S} is a function of P\mathcal{P}, and S(P)(x)\mathcal{S}(\mathcal{P})(x) of P\mathcal{P} and xx. A mesh of Γ\Gamma, a sample of that mesh, an ordering of its cells, and a list of other points are not part of P\mathcal{P}, so the solution cannot depend on them. □\square

What well-posedness excludes. Part (a) of Assumption 1 fails where a symmetric problem has several stable solutions, such as the bistable wake of a bluff body (Grandemange et al., [36]). There the solution operator is set-valued, and clause (i) of Proposition 1 states only that a rigid motion maps the solution set of P\mathcal{P} onto that of the moved problem.

Proof of Theorem 1

Full statement. Consider ISLA in exact arithmetic, with any parameters for which it is defined, when every boundary cell is a token and no weight is below its floor.

(i) Euclidean equivariance. Let R∈O(d)R \in O(d) and t∈Rdt \in\mathbb{R}^d act on the cells, their normals and data, the global directions, and the query points, with the orientation of the cells carried along under a reflection, as above. Every output of rank rr is mapped to R⊗rR^{\otimes r} times itself at the moved points (times det⁡R\det R for an output declared with odd parity).

(ii) Similarity. Multiply every coordinate by χ0>0\chi_0>0 and every datum with declared units Le0∏jSjejL^{e_0}\prod_j S_j^{e_j}, on the boundary or global, by χ0e0∏jχjej\chi_0^{e_0}\prod_j\chi_j^{e_j}, with χj>0\chi_j>0 for each declared scale SjS_j (a global value that defines SjS_j is multiplied by χj\chi_j), and leave every datum without declared units as it is. Then the internal states are unchanged, and each output, before any standardization, is multiplied by the factor of its declared units. (iii) Measure. The outputs are unchanged by a permutation of the cells, by a common rescaling of the measures given with the cells, and by replacing a cell with coincident copies that share its measure.

(iv) Query independence. The prediction at a query point is a function of that point, the boundary, and the global data only. This clause needs neither of the two hypotheses above: it holds for every opening angle θ≥0\theta\ge0 and, with a token budget, for every fixed draw.

For the interior form, (i) to (iii) hold with the exact boundary read (θ=0\theta= 0) when the boundaries form a closed surface, at every query point that has a unique closest point on it.

Write G\mathcal{G} for the transformations of clauses (i) to (iii): rigid motions, uniform rescalings of length x↦χ0x\mathbf{x} \mapsto\chi_0 \mathbf{x} (under which measures scale by χ0d−1\chi_0^{d-1}), changes of units of the declared scales, a common rescaling of the measures given with the cells, and permutations of the cells. A quantity attached to a token is invariant if it is unchanged by every element of G\mathcal{G} other than a permutation and is permuted with the cells by a permutation.

Hypotheses. The model is defined when no normalization divides by zero, for which a positive gain γ\gamma in every prototype map (Section B.3) suffices. Each weight has a floor of 10−1210^{-12} times the case’s total raw measure over all conditions, applied before the per-condition normalization, which guards the logarithm, and the theorem assumes that no weight is below it and that every cell remains a token, before and after a cell is replaced by copies. The other floors keep every normalization and logarithm defined, and a clamp on a norm commutes with RR. Boundary data are true tensors of rank at most two.

Lemma 1. Let λi\lambda_i be invariant scores and let the weights wˉi\bar{w}_i be invariant up to a common positive factor. Then αi=wˉieλi/∑jwˉjeλj\alpha_i = \bar{w}_i e^{\lambda_i} / \sum_j \bar{w}_j e^{\lambda_j} is invariant and ∑iαi=1\sum_i \alpha_i = 1. Consequently ∑iαifi\sum_i \alpha_i f_i is invariant for invariant fif_i; it maps to R∑iαiaiR \sum_i \alpha_i a_i for vectors ai↦Rai\mathbf{a}_i \mapsto R\mathbf{a}_i; and it maps to R∑iαiri+t′R \sum_i \alpha_i \mathbf{r}_i + \mathbf{t}' for points ri↦Rri+t′\mathbf{r}_i \mapsto R\mathbf{r}_i + \mathbf{t}'.

Proof. The common factor cancels in the ratio, so αi\alpha_i is invariant, and the αi\alpha_i sum to one by construction. A sum of invariant terms αifi\alpha_i f_i is then invariant. The claim for vectors holds because RR is linear, and the claim for points uses ∑iαi=1\sum_i \alpha_i = 1 to take the translation t′\mathbf{t}' out of the sum.

Inputs. The length unit of Equation (2) is a function of pairwise distances and of ratios of measures. It is therefore unchanged by rigid motions, permutations, and a common rescaling of the measures, and it is multiplied by χ0\chi_0 under x↦χ0x\mathbf{x} \mapsto\chi_0\mathbf{x}. Hence ri=xi/L\mathbf{r}_i = \mathbf{x}_i/L maps to Rri+t/LR\mathbf{r}_i + \mathbf{t}/L under a rigid motion and is unchanged by a rescaling of length. The normalized weight wˉi=eβi(b)(x)wi/Ab(i)\bar{w}_i = e^{\beta_i^{(b)}(\mathbf{x})}w_i/A_{b(i)} is a ratio of measures of the same kind, hence invariant; with a single declared condition the model uses wˉi=wi\bar{w}_i = w_i, which is invariant up to a common factor. A declared scale is a measure-weighted root-mean-square magnitude of data, or a declared global value. A change of its unit multiplies it and every datum that declares it by the same factor, so dividing each datum by its scales gives numbers that do not change with the units. The mean direction of a field that defines a scale, which the model adds to the global directions, is a normalized sum ∑iwiai\sum_i w_i\mathbf{a}_i, so it maps to RR times itself and is unchanged by the other elements of G\mathcal{G}. The invariant input of a token, the vector ηi\boldsymbol{\eta}_i from which its first state is computed (line 7 of Algorithm 1), consists of inner products of unit vectors that rotate together (n^i\hat{\mathbf{n}}_i, g^k\hat{\mathbf{g}}_k), of norms and inner products of its dimensionless data with those vectors, and of dimensionless scalars. All are invariant, including under reflections, because only true vectors enter. The first state, a per-condition map of the invariant input followed by a shared one, is therefore invariant.

Induction over the blocks. Suppose the states hi\mathbf{h}_i entering a block are invariant. The prototypes are sums of the form of Lemma 1 over invariant quantities, so they and the scores λis\lambda_{is} are invariant. By the lemma the routing weights αis0\alpha_{is}^{0} are invariant and sum to one, so the anchors satisfy rˉs↦Rrˉs+t/L\bar{\mathbf{r}}_s \mapsto R\bar{\mathbf{r}}_s + \mathbf{t}/L and ms↦Rms\mathbf{m}_s \mapsto R\mathbf{m}_s. Then ρis=ri−rˉs↦Rρis\boldsymbol{\rho}_{is} = \mathbf{r}_i - \bar{\mathbf{r}}_s \mapsto R\boldsymbol{\rho}_{is}: the translation cancels exactly, with no centering in any input of a learned map. Every component of ξis\boldsymbol{\xi}_{is} is the norm of ρis\boldsymbol{\rho}_{is}, a function of that norm, or an inner product of two of the vectors ρ^is\hat{\boldsymbol{\rho}}_{is}, n^i\hat{\mathbf{n}}_i, ms\mathbf{m}_s, g^k\hat{\mathbf{g}}_k (or a contraction of a boundary vector or tensor with ρ^is\hat{\boldsymbol{\rho}}_{is}), all of which rotate together. So ξis\boldsymbol{\xi}_{is} is invariant, and with λis\lambda_{is}, αis\alpha_{is}, wˉis\bar{w}_{is}, ZsZ_s, and the updated state. A permutation of the cells permutes per-token quantities and leaves sums over tokens unchanged. By induction the final states are invariant.

Outputs. The coefficients cic_i are an affine map of the normalized final state, hence invariant. The head’s anchors rsf\mathbf{r}_s^{\mathrm{f}} (Section B.5) are of the form of Equation (4), and a token’s soft anchor is ∑sωisfrsf\sum_s \omega_{is}^{\mathrm{f}}\mathbf{r}_s^{\mathrm{f}} with invariant weights that sum to one over the slices, so it maps to R(⋅)+t/LR(\cdot) + \mathbf{t}/L. The translation cancels in the difference between the token and its soft anchor, so u^i↦Ru^i\hat{\mathbf{u}}_i \mapsto R\hat{\mathbf{u}}_i, and every basis vector, being one of g^k\hat{\mathbf{g}}_k, n^i\hat{\mathbf{n}}_i, u^i\hat{\mathbf{u}}_i or a combination of two of them with invariant coefficients, maps as dij↦Rdijd_{ij} \mapsto R d_{ij}. The output of Equation (8) therefore maps to R⊗r\mathbb{R}^{\otimes r} times itself; the isotropic terms (the identity and its products) are fixed by R⊗r\mathbb{R}^{\otimes r}. An odd-parity output replaces exactly one factor by a cross product of two basis directions (in two dimensions, a perpendicular), which maps as det⁡(R)R(⋅)\det(R) R(\cdot), giving the extra sign; an odd output of rank dd also has the Levi-Civita tensor, which R⊗dR^{\otimes d} multiplies by det⁡R\det R. Multiplying each output by the scales of its units gives clause (ii). This proves (i) and (ii), and the permutation and rescaling parts of (iii).

Coincident copies. If a cell is replaced by nn copies with the same vertices and data and measure ai/na_i/n each, the copies have equal invariant inputs and, by induction, equal states in every layer, while every sum ∑iwˉieλifi\sum_i \bar{w}_i e^{\lambda_i} f_i is unchanged. The length unit LL is unchanged as well. Every other cell therefore keeps its output, and each copy has the output of the cell that it replaces, which proves the last part of (iii).

Queries. A query has zero weight, so it contributes to no sum over tokens: the boundary-side states, prototypes, anchors, and slice states are those of the boundary alone. Each operation on a query (its embedding, its read-back from the slices, its boundary read, its token MLP, the head) uses only the query’s own state and geometry and boundary-side quantities. In particular the list of sources of a query in the tree read is a function of the tree and of that query’s position. This proves (iv) for every θ≥0\theta\ge0, and, with a token budget, for every fixed start of the draw, as in evaluation.

The interior form with the exact boundary read. The signed distance δq\delta_q of a query is invariant under rigid motions and scales with length; where the closest boundary point is unique, the direction ν^q\hat{\nu}_q is the unit gradient of the signed distance and maps as Rν^qR\hat{\nu}_q. The sign of δq\delta_q comes from a winding number, which is exact for a closed surface. (We take the winding number as evaluated exactly; in three dimensions the implementation uses a far-field expansion with a measured error of at most 0.03, where the margin is 1/21/2.) The query’s invariant input and its relations to the anchors are then invariant as above. The pair invariants ιqj\iota_{qj} are norms and inner products of rq−rjr_q-r_j, n^j\hat{n}_j, ν^q\hat{\nu}_q, and g^k\hat{g}_k, functions of those norms and of δq/L\delta_q/L, and contractions of the boundary vectors with ρ^\hat{\rho} and ν^q\hat{\nu}_q, and the exact boundary read of Equation (9) is a sum of the form of Lemma 1 over all boundary tokens, so the query states remain invariant. The set of points with more than one closest boundary point (the medial set) has measure zero; ISLA uses the least-norm element of the convex hull of the tied directions, which is again equivariant wherever the tie is exact. □\square

The approximations. Large interior cases use two approximations that the theorem does not cover: a draw of tokens and a tree. Both depend on a frame. With a token budget below the number of cells, tokens are drawn along a Morton curve laid out in the frame of the boundary’s principal axes (signed by third moments), and with θ>0\theta> 0 the boundary tokens are grouped by a tree built in the same kind of frame. The frame moves with the boundary, and both the curve and the tree are laid out in the boundary’s own units. The draw and the tree are therefore unchanged by rigid motions and rescalings whenever the principal variances are distinct, no third moment along a principal axis vanishes, and no cell lies on a threshold of a discrete decision. Where the frame is degenerate, as for a boundary with equal principal moments or a symmetry that reverses a principal axis (a mirror plane, two-fold rotation axis, or center of symmetry), a rigid motion can regroup cells; the prediction then changes by the difference between two quadratures of the same surface, or between two tree approximations of the same sum (and on an open boundary, whose winding number is not integer-valued, the BVH far-field approximation of the winding number can also flip the sign of δq\delta_q near the threshold 1/21/2).

The tree adds an approximation of its own. A cluster replaces ∑jwˉjeζqjvj\sum_j \bar{w}_j e^{\zeta_{qj}} v_j over its members by (∑jwˉj)eζqcvc(\sum_j \bar{w}_j)e^{\zeta_{qc}} v_c at the cluster’s mean position, normal, key, and value, which is exact when the score ζqj\zeta_{qj} is constant over the cluster. The score depends on learned states as well as on geometry, so θ\theta limits how much the geometry varies over a cluster and does not limit how much the learned states vary. A model should be evaluated at the angle it was trained at.

Consistency under Remeshing and Re-sampling

A new mesh of the same surface is not one of the transformations of Theorem 1 (Figure 5), so the statement for remeshing is one of convergence, along sequences of meshes of the following kind. Call a sequence of meshes of a compact, oriented, piecewise C2C^2 surface F\mathcal{F} admissible if

Figure 5. Measure-weighted slice pooling converges under mesh refinement; count-normalized pooling does not. (a) A Joukowski airfoil in potential flow, discretized into N=96N = 96 boundary cells that are about nine times shorter at the leading edge, with six soft slices. Bars show the slice states of the exact cpc_p pooled by soft counts (gray) and by cell measure (charcoal, ISLA) beside the exact ratio of surface integrals (crimson ticks). (b) Largest error across the six slice states as the same grading law is refined from N=24N = 24 to 4,0964{,}096: count-normalized pooling stays near 0.12, its mesh-density-weighted limit, whereas ISLA’s measure-weighted pooling falls by five decades as N−2N^{-2}.

  • (a) every cell has its vertices on the closure of one smooth piece of one condition, on which the data are continuous;

  • (b) the closest-point projection onto that piece is one-to-one on the cells and onto the piece, up to sets whose measure tends to zero;

(c) the largest cell diameter ℓ\ell tends to zero; and

(d) max⁡i∥n^i−n(xi∗)∥→0\max_i\lVert\hat{\mathbf{n}}_i-\mathbf{n}(x_i^*)\rVert\to0, where n\mathbf{n} is the unit normal of Γ\Gamma and xi∗x_i^* is the point of the cell’s piece closest to the centroid xix_i.

Shape-regular triangulations that satisfy (a) to (c) and are oriented as Γ\Gamma satisfy (d) [30]; in two dimensions (d) follows from (a) to (c) and the orientation. Condition (d) is needed: inscribed triangulations of a cylinder can have diameters that tend to zero and areas that diverge.

Proposition 2 (Consistency under remeshing and re-sampling). Let Γ\Gamma be compact, oriented, and piecewise C2C^2, and let λ\lambda and ff be bounded on Γ\Gamma and continuous on each smooth piece of each condition.

(i) Along an admissible sequence of meshes, ∑isoftmax⁡iwˉ(λ(xi∗))f(xi∗)→∫Γeλf dSˉ∫Γeλ dSˉ\sum_i \operatorname{softmax}_{i}^{\bar{w}}(\lambda(x_i^*))f(x_i^*)\to\frac{\int_\Gamma e^\lambda f\,d\bar{S}}{\int_\Gamma e^\lambda\,d\bar{S}}, with dSˉ=eβb dS/∣Γb∣d\bar{S}=e^{\beta_b}\,dS/|\Gamma_b| on Γb\Gamma_b (and dSˉ=dSd\bar{S}=dS with one declared condition). Without the measure, if the empirical distribution of the centroids converges to a density, the same sum converges to a ratio of integrals against that density, which depends on the mesher.

(ii) Let a design keep cell ii with probability πi>0\pi_i>0 and weight ai/πia_i/\pi_i. For scores and values that do not depend on the sample, the numerator and the denominator of the sampled sum are unbiased for their full-mesh values. This uses first-order inclusion probabilities only, so it holds for the systematic design of Section B.2 with a random start. Here AbA_b is the measure of the full mesh, which the model computes before the draw.

(iii) Fix parameters for which the model is defined, with a positive gain γ\gamma in every prototype map, and take the model without the floor on the weights. Let Γ\Gamma be closed, let the data of cell ii be the values at xi∗x_i^* of data that are continuous on each smooth piece of each condition, let every boundary cell be a token, and let the boundary read be exact (θ=0\theta=0). Then there is a field YY on Γ\Gamma with max⁡i∥Yi−Y(xi∗)∥→0\max_i\lVert Y_i-Y(x_i^*)\rVert\to0 along every admissible sequence, and the output at every fixed query point off Γ\Gamma that has a unique closest point on Γ\Gamma converges. The limits depend on Γ\Gamma, its data, the global data, and the parameters, and not on the sequence.

Proof. (i) Let Γ\Gamma be bounded on Γ\Gamma and continuous on each smooth piece of each condition. For an admissible sequence, ∑i∈Γbai→∣Γb∣\sum_{i\in\Gamma_b}a_i\to|\Gamma_b| and ∥xi−xi∗∥=O(ℓ2)\lVert x_i-x_i^*\rVert=O(\ell^2) [30], so ∑iaiF(xi∗)\sum_i a_iF(x_i^*) is a Riemann sum and converges to ∫ΓF dS\int_\Gamma F\,dS. Apply this on each condition to F=eλfF=e^\lambda f and to F=eλF=e^\lambda, whose integral is positive; the ratio converges because division is continuous away from zero. Without the measure, 1N∑iF(xi∗)\frac{1}{N}\sum_iF(x_i^*) converges to ∫ΓF dS\int_\Gamma F\,dS whenever the empirical distribution of the points converges to a density ϱ\varrho, and ϱ\varrho is set by the mesher. (ii) Let IiI_i indicate that cell ii is kept. Then E[∑iIi(ai/πi)Fi]=∑iaiFi\mathbb{E}\left[\sum_i I_i(a_i/\pi_i)F_i\right]=\sum_i a_iF_i for every fixed FF [43]; this holds for the numerator (F=eλfF=e^{\lambda f}) and the denominator (F=eλF=e^\lambda). Their ratio is the Hájek estimator [40, 75], which is not unbiased. The hypothesis that the scores and values do not depend on the sample holds in the prototype attention of the first block; elsewhere they are functions of sampled sums. For the systematic design and every start u0∈[0,1)u_0 \in[0,1), including the fixed start of evaluation, the error of each sum is bounded without any assumption of independence. With s(t)=aiFi/πis(t)=a_iF_i/\pi_i for tt in the interval of cell ii on the line on which the cells are laid, ∑iaiFi=∫0Bs\sum_i a_iF_i=\int_0^B s and the estimate is ∑m=0B−1s(u0+m)\sum_{m=0}^{B-1}s(u_0+m), so

∣∑i keptaiπiFi−∑iaiFi∣≤∑m=0B−1osc⁡m(s).(10)\left|\sum_{i\ \mathrm{kept}}\frac{a_i}{\pi_i}F_i-\sum_i a_iF_i\right|\leq\sum_{m=0}^{B-1}\operatorname{osc}_m(s). \tag*{(10)}

where osc⁡m(s)\operatorname{osc}_m(s) is the oscillation of ss over the mm-th unit interval. Within a condition ai/πia_i/\pi_i equals the threshold ab∗a_b^* of Section B.2 for every cell with πi<1\pi_i<1, so on those cells s=ab∗Fis=a_b^*F_i, and its oscillation over a unit interval is ab∗a_b^* times that of FF over the cells that the interval contains. The error of each sum, relative to ∑iai∣Fi∣\sum_i a_i|F_i|, therefore vanishes when eλfe^{\lambda f} and eλe^\lambda vary little over those cells in all but a vanishing share of the intervals, as when the mesh and the budget are refined together. For B=NB=N every interval is one cell and the error is zero, but the bound does not tend to zero as B→NB\to N on a fixed mesh. We claim no rate.

(iii) Every map in a block is continuous: each normalization and each logarithm has a positive floor on its argument, and the remaining operations are affine maps, GELU, exponentials, and ratios with positive denominators. Suppose that at the input of a block there is a bounded field H:Γ→RCH:\Gamma\to\mathbb{R}^C, continuous on each smooth piece of each condition, with max⁡i∥hi−H(xi∗)∥→0\max_i\lVert h_i-H(x_i^*)\rVert\to0 as ℓ→0\ell\to0. For the first block HH is the embedding of the invariant input, a continuous function of the normal field and the data, and condition (d) gives the convergence. By (i) and uniform continuity on bounded sets, every sum over tokens in the block converges to the corresponding ratio of surface integrals of HH, the anchors converge, and the updated states converge to the values of a new field of the same kind at the points xi∗x_i^*. By induction the outputs at the tokens converge to the values of a field YY determined by Γ\Gamma, its data, the global data, and the parameters. The length unit of the mesh converges to that of Γ\Gamma by (i), and the signed distance and the direction of a fixed query point off the closed surface Γ\Gamma converge wherever its closest point is unique, so the output at the query converges too.

With a fixed token budget, or with θ>0\theta>0, the outputs converge only up to the sampling error of the draw and the error of the tree, which Section D.5 measures. With the floor of 10−1210^{-12} of the total weight, the model equals that of clause (iii) on every mesh whose smallest weight exceeds the floor (fewer than about 101210^{12} cells of comparable size), and not in the limit.

Order of convergence under a geometric split. If a flat cell EE with centroid xE\mathbf{x}_E is split into cells E1,E2E_1,E_2 that tile it, then a1x1+a2x2=aExEa_1\mathbf{x}_1+a_2\mathbf{x}_2=a_E\mathbf{x}_E, so for a twice-differentiable summand the first-order terms cancel and ∑mamF′(xm)−aEF(xE)=O(aEℓ2)\sum_m a_mF'(x_m)-a_EF(x_E)=O(a_E\ell^2): the token sums are second-order consistent. The length unit is exactly unchanged, because Equation (2) is evaluated with each cell’s own second moment (Section B). This is a statement about splitting the flat cells of one polyhedral surface; for two meshes of a curved surface, Proposition 2 gives convergence and no rate.

Architecture in Full

This appendix specifies the forward pass in full. Figure 6 maps the dataflow and tensor shapes across the boundary, slice, and interior-query paths, Algorithm 1 gives the computation step by step for boundary data of rank zero, the subsections define the pieces that the main text only names, and Section B.4 adds boundary vectors and tensors. Throughout, LN is a layer normalization over the CC channels of one token, cs⁡(a,b)=a⋅b/(∥a∥∥b∥)\operatorname{cs}(\mathbf{a},\mathbf{b})=\mathbf{a}\cdot\mathbf{b}/(\lVert\mathbf{a}\rVert\lVert\mathbf{b}\rVert) is the cosine similarity of two vectors, softmax⁡w~\operatorname{softmax}_{\tilde w} is the measure-weighted softmax over tokens of Equation (3), and softmax⁡s\operatorname{softmax}_s is an unweighted softmax over slices. Logarithms and normalizations have small positive floors, relative to the case’s own scales, which the equations omit.

Figure 6. The forward pass of ISLA, with the shape of every tensor. Left: the boundary is scaled once, tokens are drawn with Horvitz–Thompson weights, and initial states are embedded from invariants without coordinates. Center: each of 12 blocks passes states from the NN boundary tokens (blue) to the MM slices (amber) and back in four steps: route, anchor, relate, and mix and read back. Gray: the per-block states and token trees stored once per case. Bottom: interior query points (wˉq=0\bar{w}_q=0), an independent input, read the stored slices and, through the tree, the boundary tokens without contributing to any sum over tokens, so arbitrary query sets run in chunks. Right: the equivariant tensor-basis head.

The Length Unit and the Scales

For a mesh with cells (segments or triangles) of measure aia_i, centroid xix_i, and vertices xivx_{iv}, v=0,…,nv=0,\ldots,n with n=d−1n=d-1, let A=∑jajA=\sum_j a_j and xˉ=∑iaixi/A\bar{x}=\sum_i a_ix_i/A. The length unit of Equation (2), the root-mean-square distance between two points of the surface, is evaluated exactly for the piecewise-flat surface by

L2=2A∑iai(∥xi−xˉ∥2+Ji),Ji=1(n+1)(n+2)∑v=0n∥xiv−xi∥2(11)L^2 = \frac{2}{A} \sum_i a_i \left(\lVert x_i-\bar{x}\rVert^2 + J_i\right), \qquad J_i = \frac{1}{(n+1)(n+2)} \sum_{v=0}^{n} \lVert x_{iv}-x_i\rVert^2 \tag*{(11)}

where JiJ_i is the second moment of cell ii about its own centroid per unit measure. The identity 1A2∬∥x−y∥2=2Var⁡(x)\frac{1}{A^2}\iint\lVert x-y\rVert^2 = 2\operatorname{Var}(x) gives the O(N)O(N) form, and the term JiJ_i makes LL exactly unchanged when a cell is split into cells that tile it. LL is 2\sqrt{2} times the radius of gyration of the surface. On the surface tasks of this paper the cells given to the model are the data pipeline’s sample with Horvitz–Thompson measures, so there LL and the AbA_b are estimates from that sample. The mean position xˉ\bar{x} appears inside this one scalar and in no input of a learned map.

The other scales come from the declarations of a problem’s fields. The declaration of a field, an input or an output, may state its units as a monomial in named scales, and may state that the field defines one of them. A scale defined by a boundary vector field, such as an inlet’s prescribed velocity, its measure-weighted root-mean-square magnitude over the cells that carry it, and the measure-weighted mean direction of that field becomes one of the global directions g^k\hat{\mathbf{g}}_k. A scale may also be given directly as a global value, such as a density. Scales are computed in float64 from the full-resolution boundary, before any token is drawn. Each input with units is divided by the monomial of its scales and each output is multiplied by its own. A Reynolds number, where a problem has one, is an ordinary global scalar formed from the problem’s own scales and viscosity; the model itself names no physical quantity. In this paper AeroZoo declares a velocity and a density scale, and AirfRANS a velocity scale. The automotive datasets hold one flow condition each and declare none: their data pipeline makes the targets dimensionless with the dataset’s free-stream constants, and only LL depends on the size of the geometry. A global vector contributes only its direction, because the outputs do not scale as any fixed power of its magnitude; a magnitude that matters enters as a scale or as a scalar.

Drawing Boundary Tokens

When an interior task’s boundary has more cells than the budget BB, tokens are drawn as follows.

  1. Shares. The budget is divided among the conditions by water filling: equal shares, except that a condition with fewer cells than its share is kept whole and its unused share is passed to the others.

  1. Inclusion probabilities. Within a condition with share BbB_b, cell ii is kept with probability πi=min⁡(1,ai/ab∗)\pi_i=\min(1,a_i/a_b^*), where the

Algorithm 1 The forward pass of ISLA for one case. The index ii runs over boundary tokens, bb over conditions, ss over slices, ll over blocks, qq over query points, jj over the sources of a boundary read, hh over its heads, and oo over output tokens. Lines 25 to 39 and the steps marked “(interior)” run only for interior tasks.

Require: boundary cells (xi,n^i,ai,data)(\mathbf{x}_i,\hat{\mathbf{n}}_i,a_i,\mathrm{data}) grouped by condition bb; global directions g^k\hat{\mathbf{g}}_k and scalars σ\sigma; query points xq\mathbf{x}_q (interior task)

  1. L←L \leftarrow root-mean-square pairwise distance of the surface, Equation (11)

  2. declared scales from the data; divide every datum by its scale

  3. Ab←∑i∈baiA_b \leftarrow\sum_{i\in b}a_i

  4. (interior) if the cells outnumber the budget BB: draw BB tokens, wi←ai/πiw_i \leftarrow a_i/\pi_i (Section B.2); else wi←aiw_i \leftarrow a_i

  5. wˉi←eβb(i)wi/Ab(i)\bar{w}_i \leftarrow e^{\beta_{b(i)}w_i/A_{b(i)}}

  6. ri←xi/L\mathbf{r}_i \leftarrow\mathbf{x}_i/L

  7. hi←WeGELU⁡(Wb(i)ηi)+be\mathbf{h}_i \leftarrow W_e\operatorname{GELU}(W_{b(i)}\eta_i)+\mathbf{b}_e with invariant input ηi=[1,n^i⋅g^k, invariants of the data,σ]\eta_i=[1,\hat{\mathbf{n}}_i\cdot\hat{\mathbf{g}}_k,\text{ invariants of the data},\sigma]

  8. for l=1,…,12l=1,\ldots,12 do

  9. h~i←LN⁡(hi)\tilde{\mathbf{h}}_i \leftarrow\operatorname{LN}(\mathbf{h}_i)

  10. prototypes ps\mathbf{p}_s from h~\tilde{\mathbf{h}} (Section B.3)

  11. λis←τ cs⁡(h~i,ps)\lambda_{is}\leftarrow\tau\,\operatorname{cs}(\tilde{\mathbf{h}}_i,\mathbf{p}_s)

  12. αis0←softmax⁡wˉi(λis)\alpha^0_{is}\leftarrow\operatorname{softmax}_{\bar{w}_i}(\lambda_{is}) (over tokens ii)

  13. rˉs←∑iαis0ri\bar{\mathbf{r}}_s\leftarrow\sum_i\alpha^0_{is}\mathbf{r}_i

  14. ms←normalize⁡(∑iαis0n^i)\mathbf{m}_s\leftarrow\operatorname{normalize}(\sum_i\alpha^0_{is}\hat{\mathbf{n}}_i)

  15. ξis←\xi_{is}\leftarrow relational invariants of (ri−rˉs,n^i,ms,g^k)(\mathbf{r}_i-\bar{\mathbf{r}}_s,\hat{\mathbf{n}}_i,\mathbf{m}_s,\hat{\mathbf{g}}_k), Equation (5)

  16. λis′←λis+wξ⋅ξis\lambda'_{is}\leftarrow\lambda_{is}+w_\xi\cdot\xi_{is}

  17. αis←softmax⁡wˉi(λis′)\alpha_{is}\leftarrow\operatorname{softmax}_{\bar{w}_i}(\lambda'_{is}) (over tokens ii)

  18. ωis←softmax⁡s(λis′)\omega_{is}\leftarrow\operatorname{softmax}_s(\lambda'_{is}) (over slices ss)

  19. Zs←∑iαish~i\mathbf{Z}_s\leftarrow\sum_i\alpha_{is}\tilde{\mathbf{h}}_i

  20. Zs←Zs+MLP⁡slice(LN⁡(Zs))\mathbf{Z}_s\leftarrow\mathbf{Z}_s+\operatorname{MLP}_{\mathrm{slice}}(\operatorname{LN}(\mathbf{Z}_s))

  21. hi←hi+Wr[h~i;∑sωisZs;Wf∑sωisξis+bf]+br\mathbf{h}_i\leftarrow\mathbf{h}_i+W_r[\tilde{\mathbf{h}}_i;\sum_s\omega_{is}\mathbf{Z}_s;W_f\sum_s\omega_{is}\xi_{is}+\mathbf{b}_f]+\mathbf{b}_r

  22. hi←hi+MLP⁡(LN⁡(hi))\mathbf{h}_i\leftarrow\mathbf{h}_i+\operatorname{MLP}(\operatorname{LN}(\mathbf{h}_i))

  23. (interior) store (p,rˉ,m,Z)(l)(\mathbf{p},\bar{\mathbf{r}},\mathbf{m},\mathbf{Z})^{(l)} and the tokens’ keys and values kj(l),vj(l)\mathbf{k}^{(l)}_j,\mathbf{v}^{(l)}_j

  24. end for

  25. (δq,ν^q)←(\delta_q,\hat{\boldsymbol{\nu}}_q)\leftarrow exact signed distance and direction to the full surface (Section B.6)

  26. rq←xq/L\mathbf{r}_q\leftarrow\mathbf{x}_q/L

  27. hq←WeGELU⁡(Win[ν^q⋅g^k,σ,δq/L,asinh⁡(106δq/L)]+bin)+be\mathbf{h}_q\leftarrow W_e\operatorname{GELU}(W_{\mathrm{in}}[\hat{\boldsymbol{\nu}}_q\cdot\hat{\mathbf{g}}_k,\sigma,\delta_q/L,\operatorname{asinh}(10^6\delta_q/L)]+\mathbf{b}_{\mathrm{in}})+\mathbf{b}_e

  28. sources Jq←\mathcal{J}_q\leftarrow tokens and accepted clusters of the tree (Section B.7)

  29. ϕqj←MLP⁡basis(ιqj)\phi_{qj}\leftarrow\operatorname{MLP}_{\mathrm{basis}}(\iota_{qj}) for j∈Jqj\in\mathcal{J}_q

  30. for l=1,…,12l=1,\ldots,12 do

  31. h~q←LN⁡(hq)\tilde{\mathbf{h}}_q\leftarrow\operatorname{LN}(\mathbf{h}_q)

  32. ξqs←\xi_{qs}\leftarrow relational invariants of (rq−rˉs(l),ν^q,ms(l),g^k)(\mathbf{r}_q-\bar{\mathbf{r}}_s^{(l)},\hat{\boldsymbol{\nu}}_q,\mathbf{m}_s^{(l)},\hat{\mathbf{g}}_k)

  33. λqs′←τ cs⁡(h~q,ps(l))+wξ⋅ξqs\lambda'_{qs}\leftarrow\tau\,\operatorname{cs}(\tilde{\mathbf{h}}_q,\mathbf{p}_s^{(l)})+w_\xi\cdot\xi_{qs}

  34. ωqs←softmax⁡s(λqs′)\omega_{qs}\leftarrow\operatorname{softmax}_s(\lambda'_{qs}) (over slices ss)

  35. hq←hq+Wr[h~q;∑sωqsZs(l);Wf∑sωqsξqs+bf]+br\mathbf{h}_q\leftarrow\mathbf{h}_q+W_r[\tilde{\mathbf{h}}_q;\sum_s\omega_{qs}\mathbf{Z}_s^{(l)};W_f\sum_s\omega_{qs}\xi_{qs}+\mathbf{b}_f]+\mathbf{b}_r

  36. hq←hq+MLP⁡(LN⁡(hq))\mathbf{h}_q\leftarrow\mathbf{h}_q+\operatorname{MLP}(\operatorname{LN}(\mathbf{h}_q))

  37. ζqjh←wκh⋅ϕqj+⟨qqh,kjh(l)⟩/ck\zeta_{qjh}\leftarrow w^h_\kappa\cdot\phi_{qj}+\langle\mathbf{q}_{qh},\mathbf{k}^{(l)}_{jh}\rangle/\sqrt{c_k} for each head hh, with qqh=WhqLN⁡(hq)\mathbf{q}_{qh}=W^q_h\operatorname{LN}(\mathbf{h}_q)

  38. hq←hq+Wo[∑j∈Jqsoftmax⁡wˉj(ζqjh)vjh(l)]h=1,…,8\mathbf{h}_q\leftarrow\mathbf{h}_q+W^o[\sum_{j\in\mathcal{J}_q}\operatorname{softmax}_{\bar{w}_j}(\zeta_{qjh})\mathbf{v}^{(l)}_{jh}]_{h=1,\ldots,8}

  39. end for

  40. output tokens oo: the cells of the requested boundaries (surface task) or the queries (interior task)

  41. co←WhLN⁡(ho)+bh\mathbf{c}_o\leftarrow W_h\operatorname{LN}(\mathbf{h}_o)+\mathbf{b}_h

  42. u^o←\hat{\mathbf{u}}_o\leftarrow direction from the token’s soft anchor (Section B.5)

  43. Yo←∑j1…jrco,j1…jrdoj1⊗⋯⊗dojr+isotropic terms\mathbf{Y}_o\leftarrow\sum_{j_1\ldots j_r}c_{o,j_1\ldots j_r}\mathbf{d}_{o j_1}\otimes\cdots\otimes\mathbf{d}_{o j_r}+\text{isotropic terms}, per declared field

  44. multiply each output by the scales of its units

threshold ab∗a_b^* makes ∑iπi=Bb\sum_i\pi_i=B_b.

Order

Within each condition, the cells are sorted along a Morton (Z-order) curve (Morton, 1966) of their centroids, and the conditions are laid one after another. The curve lies in the frame of the boundary’s measure-weighted principal axes, each axis signed so that the third moment along it is positive, and in units of the boundary’s own extent. The frame moves with the boundary, so in exact arithmetic the same cells are kept in every pose and at every scale, except where two principal variances are equal, a third moment vanishes (as for a mirror-symmetric boundary), or a centroid lies on a grid line of the curve. In float32, rounding moves cells across such lines: a rigid motion changes 9% of the drawn tokens on DrivAerML (Section D.5).

  1. Systematic draw. The cells are laid end to end as intervals of length πi\pi_i, and the cells that contain the points u0u_0, u0+1u_0 + 1, u0+2u_0 + 2, . . . are kept [61], with the start u0u_0 uniform on [0,1)[0, 1) in training and u0=1/2u_0 = 1/2 in evaluation, so that inference is deterministic.

  1. Weights. A kept cell has the weight wi=ai/πiw_i = a_i/\pi_i.

The number of tokens is exactly min⁡(N,B)\min(N, B). In training every cell is kept with probability exactly πi\pi_i, so every sum ∑iwiFi\sum_i w_i F_i with FF independent of the draw is an unbiased estimate of the sum over all cells, and it is exact for a condition that is kept whole. Ordering along a space-filling curve spreads the sample over the surface [83]. Since large cells are kept with certainty and small cells in proportion to their area, the tokens of a finely meshed region do not crowd out the rest of the boundary.

A surface task uses every cell that it is given, with the measures that it is given. On the surface tasks of this paper the data pipeline draws 200,000 cells of the body uniformly, multiplies their measures by the inverse of the sampling fraction, and passes the tunnel’s boundaries whole.

Prototypes Adapted to the Case

Each block has learned base prototypes ws∈RC\mathbf{w}_s \in\mathbb{R}^{C}, s=1,…,Ms = 1, \ldots, M, and adapts them to the case by one measure-weighted attention,

Δs=∑iwˉisoftmax⁡(1Cws⋅Wpkh~i)Wpvh~i,(12)\Delta_s = \sum_i \bar{w}_i \operatorname{softmax}\left(\frac{1}{\sqrt{C}} \mathbf{w}_s \cdot W^{pk}\tilde{\mathbf{h}}_i\right) W^{pv}\tilde{\mathbf{h}}_i, \tag*{(12)}
Δsc=Δs−1M∑t=1MΔt,(13)\Delta_s^c = \Delta_s - \frac{1}{M}\sum_{t=1}^{M}\Delta_t, \tag*{(13)}
γˉ=γrms⁡(w),ps=ws+γˉrms⁡(Δc)+γˉΔsc,(14)\bar{\gamma} = \gamma\operatorname{rms}(\mathbf{w}), \qquad\mathbf{p}_s = \mathbf{w}_s + \frac{\bar{\gamma}}{\operatorname{rms}(\Delta^c) + \bar{\gamma}}\Delta_s^c, \tag*{(14)}

where Δs\Delta_s is the summary of the case that the attention forms for slice ss, rms is the root mean square over all MCMC components of its argument, and γ\gamma is a learned gain, initialized to 0.1. Centering removes the part of the summaries that is common to all slices, and for γ>0\gamma> 0 the last factor keeps the root-mean-square size of the adaptation below a fraction γ\gamma of that of the base prototypes. The cosine-similarity score is bounded, λis∈[−τ,τ]\lambda_{is} \in[-\tau, \tau], so the first routing cannot sharpen without limit as the weights grow. The refinement wξ⋅ξis\mathbf{w}_{\xi} \cdot\boldsymbol{\xi}_{is} adds a learned linear function of the invariants, without a bias. It contains the distance and its logarithm, so it is not bounded.

Boundary Data of Rank One and Two

A condition may prescribe vectors ap\mathbf{a}_p on its cells, such as an inlet’s velocity, and a rank-2 tensor TT. With the frame vectors f0=n^i\mathbf{f}_0 = \hat{\mathbf{n}}_i and fa=g^a\mathbf{f}_a = \hat{\mathbf{g}}_a, a token’s invariant input contains the invariants of these data: ap⋅fa\mathbf{a}_p \cdot\mathbf{f}_a, ∥ap∥\lVert\mathbf{a}_p\rVert, ap⋅ap′\mathbf{a}_p \cdot\mathbf{a}_{p'}, faTTfb\mathbf{f}_a^{\mathsf{T}} T \mathbf{f}_b, the trace of TT, and its Frobenius norm. Each condition also maps its vectors (and the vectors TfaT\mathbf{f}_a) onto a set of vector channels shared by all conditions, and its tensors onto shared tensor channels, by learned scalar matrices initialized to the identity. A combination of vectors with scalar weights commutes with every rotation and reflection, so the channels VipV_{ip} and TiT_i remain true vectors and tensors. They enter each block through the contractions ρ^i⋅Vip\hat{\rho}_i \cdot V_{ip} and ρ^iTTiρ^i\hat{\rho}_i^{\mathsf{T}} T_i \hat{\rho}_i, which join the relational invariants of (5), and the boundary read through ρ^⋅Vip\hat{\rho} \cdot V_{ip} and ρ^q⋅v^q\hat{\rho}_q \cdot\hat{\mathbf{v}}_q, which join the pair invariants of Section B.7. Query points have zeros in these channels. On the DrivAerML tasks, which have no boundary data and one global direction, the relational invariants number six. The model accepts global scalars and unit directions only, so a problem whose global data hold a rank-2 material tensor or a pseudovector, such as a rotation rate, cannot be posed to it in full. The interior form accepts boundary data of rank zero and one only.

Output Basis

The basis of (8) contains the direction u^o\hat{\mathbf{u}}_o to each output token oo from a soft anchor of its own. To form it, one more routing map, with its own prototypes psf\mathbf{p}^{f}_s and without the geometric refinement, is applied to the final states; its prototypes are adapted to the case as in Section B.3, with the final states hi\mathbf{h}_i in place of h~i\tilde{\mathbf{h}}_i:

αisf=softmax⁡i(τ cs⁡(hi,psf)),rˉsf=∑iαisfri(15)\alpha_{is}^{\mathrm{f}}=\operatorname{softmax}_{i}\left(\tau\,\operatorname{cs}(\mathbf{h}_i,\mathbf{p}_s^{\mathrm{f}})\right), \qquad\bar{\mathbf{r}}_s^{\mathrm{f}}=\sum_i\alpha_{is}^{\mathrm{f}}\mathbf{r}_i \tag*{(15)}
ωosf=softmax⁡s(τ cs⁡(ho,psf)),u^o=ro−∑sωosfrˉsf∥ro−∑sωosfrˉsf∥(16)\omega_{os}^{\mathrm{f}}=\operatorname{softmax}_{s}\left(\tau\,\operatorname{cs}(\mathbf{h}_o,\mathbf{p}_s^{\mathrm{f}})\right), \qquad\hat{\mathbf{u}}_o=\frac{\mathbf{r}_o-\sum_s\omega_{os}^{\mathrm{f}}\bar{\mathbf{r}}_s^{\mathrm{f}}}{\left\lVert\mathbf{r}_o-\sum_s\omega_{os}^{\mathrm{f}}\bar{\mathbf{r}}_s^{\mathrm{f}}\right\rVert} \tag*{(16)}

The soft anchor of token oo is ∑sωosfrˉsf\sum_s\omega_{os}^{\mathrm{f}}\bar{\mathbf{r}}_s^{\mathrm{f}}, and u^o\hat{\mathbf{u}}_o is the direction from it to the token. The anchors rˉsf\bar{\mathbf{r}}_s^{\mathrm{f}} are formed by the boundary tokens alone. With KK global directions the true basis vectors are

do=(g^1,…,g^K,n^o,u^o,e(u^o,n^o),e(u^o,g^1),…,e(u^o,g^K)),e(u^,a)=−(a−(a⋅u^)u^)(17)\mathbf{d}_o=\left(\hat{\mathbf{g}}_1,\ldots,\hat{\mathbf{g}}_K,\hat{\mathbf{n}}_o,\hat{\mathbf{u}}_o,e(\hat{\mathbf{u}}_o,\hat{\mathbf{n}}_o),e(\hat{\mathbf{u}}_o,\hat{\mathbf{g}}_1),\ldots,e(\hat{\mathbf{u}}_o,\hat{\mathbf{g}}_K)\right), \qquad e(\hat{\mathbf{u}},\mathbf{a})=-\left(\mathbf{a}-(\mathbf{a}\cdot\hat{\mathbf{u}})\hat{\mathbf{u}}\right) \tag*{(17)}

m=2K+3m=2K+3 in all, where e(u^,a)e(\hat{\mathbf{u}},\mathbf{a}) is minus the part of a\mathbf{a} that is perpendicular to u^\hat{\mathbf{u}}. For a query, ν^q\hat{\boldsymbol{\nu}}_q takes the place of n^o\hat{\mathbf{n}}_o. An even-parity output of rank rr is the contraction of mrm^r coefficients with the products doj1⊗⋯⊗dojr\mathbf{d}_{o j_1}\otimes\cdots\otimes\mathbf{d}_{o j_r}, plus the isotropic tensors of that rank (the identity at rank 2). A symmetric output uses one coefficient per unordered multi-index. An odd-parity output replaces exactly one factor by a pseudovector: in three dimensions a cross product of two of g^k\hat{\mathbf{g}}_k, n^o\hat{\mathbf{n}}_o, u^o\hat{\mathbf{u}}_o, and in two dimensions the perpendicular of one of them. An odd output of rank dd also has the Levi-Civita tensor. With one global direction in three dimensions a vector uses 5 coefficients, a symmetric rank-2 tensor 16, and a pseudovector 3.

The span of the true basis is that of {g^k,n^o,u^o}\{\hat{\mathbf{g}}_k,\hat{\mathbf{n}}_o,\hat{\mathbf{u}}_o\}, of dimension at most min⁡(d,K+2)\min(d,K+2). With at least one global direction it is all of R3\mathbb{R}^3 except where the three directions are coplanar. With none (K=0K=0) in three dimensions, every even vector output lies in the plane of n^o\hat{\mathbf{n}}_o and u^o\hat{\mathbf{u}}_o. For general vector outputs such a problem needs a declared direction, or a boundary vector field that defines a scale, whose mean direction then becomes a global direction.

Exact Geometry of a Query Point

A query point receives two geometric quantities: its signed distance δq\delta_q to the surface, and the direction ν^q\hat{\boldsymbol{\nu}}_q in which that distance increases. The surface is the union of all cells of all given boundaries at full resolution, never the drawn tokens. For a query xq\mathbf{x}_q an exact point-to-simplex search (on a bounding-volume hierarchy in three dimensions) finds the closest point xq∗\mathbf{x}_q^* of the surface, and

δq=±∥xq−xq∗∥,ν^q=sign⁡(δq)xq−xq∗∥xq−xq∗∥(18)\delta_q=\pm\left\lVert\mathbf{x}_q-\mathbf{x}_q^*\right\rVert,\qquad\hat{\boldsymbol{\nu}}_q=\operatorname{sign}(\delta_q)\frac{\mathbf{x}_q-\mathbf{x}_q^*}{\left\lVert\mathbf{x}_q-\mathbf{x}_q^*\right\rVert} \tag*{(18)}

with the sign positive on the side that the cells’ normals point to. The sign is taken from the generalized winding number of the oriented cells [45], evaluated with a hierarchical far-field expansion in three dimensions [12]. It is therefore defined at folds of the surface, where cells meet back to back and a sign taken from the nearest cell’s normal would depend on rounding. For a closed surface the sign is exact; behind an isolated open sheet it is approximate near the level at which the winding number changes sign. Where the closest point lies inside a cell, ν^q\hat{\boldsymbol{\nu}}_q is that cell’s normal, including at a point on the surface itself. At a point with several closest features, such as the mid-plane of a thin plate, the gradient of the distance is not defined. There ISLA takes the least-norm point of the convex hull of the tied directions (the midpoint of two, zero where they cancel), which is a function of the tied features alone and not of the order of the mesh. Both δq\delta_q and ν^q\hat{\boldsymbol{\nu}}_q are functions of the surface: they are the same for every draw of the tokens and are unchanged when a cell is split. This is why ISLA takes no stored signed-distance field. The channel asinh⁡(106δq/L)\operatorname{asinh}(10^6\delta_q/L) is logarithmic for distances above 10−6L10^{-6}L, so that the viscous sublayer and the far wake are both resolved, and are linear through the wall.

The Boundary Read and Its Tree

The boundary read of Equation (9) scores a query qq and a source jj by a learned kernel of the pair’s invariants plus an inner product of the query’s vector and the source’s key. For a source with position rj\mathbf{r}_j and normal n^j\hat{\mathbf{n}}_j, let ρ=rq−rj\boldsymbol{\rho}=\mathbf{r}_q-\mathbf{r}_j. The pair invariants are

vqj=[∥ρ∥,log⁡∥ρ∥,log⁡(∥ρ∥L/∣δq∣),ρ^⋅n^j,ρ^⋅ν^q,ν^q⋅n^j,ρ^⋅g^k,n^j⋅g^k](19)v_{qj}=\left[\left\lVert\boldsymbol{\rho}\right\rVert,\log\left\lVert\boldsymbol{\rho}\right\rVert,\log\left(\left\lVert\boldsymbol{\rho}\right\rVert L/\left|\delta_q\right|\right),\hat{\boldsymbol{\rho}}\cdot\hat{\mathbf{n}}_j,\hat{\boldsymbol{\rho}}\cdot\hat{\boldsymbol{\nu}}_q,\hat{\boldsymbol{\nu}}_q\cdot\hat{\mathbf{n}}_j,\hat{\boldsymbol{\rho}}\cdot\hat{\mathbf{g}}_k,\hat{\mathbf{n}}_j\cdot\hat{\mathbf{g}}_k\right] \tag*{(19)}

together with the contractions of any boundary vector data with ρ^\hat{\boldsymbol{\rho}} and ν^q\hat{\boldsymbol{\nu}}_q. A small MLP maps them once per forward pass to 16 basis functions ϕqj\phi_{qj}, which all layers share. Each layer and each of its 8 heads has its own kernel, the linear combination whk⋅ϕqjw_h^k\cdot\phi_{qj}, and its own keys and values of the boundary tokens’ states (4 key and 8 value channels per head). The output projection WoW^o of each layer is initialized to zero.

The tokens of each condition are first grouped by the face of a cube that their normal points to in the boundary’s principal frame. Each group forms a binary radix tree over a Morton order of its tokens (Karras, [49]), with leaves of at most four tokens. A node cc stores the sum wˉc\bar{w}_c of its tokens’ weights and the measure-weighted means of their positions, normals (renormalized to unit length), keys, and values. A query traverses each tree from the root and accepts a node as one virtual token when both

diam⁡(c)<θdist⁡(xq,c),(20)\operatorname{diam}(c)<\theta\operatorname{dist}(x_q,c), \tag*{(20)}
∥∑j∈cwˉjn^j∥/wˉc>1−θ2/2,(21)\left\lVert\sum_{j\in c}\bar{w}_j\hat{n}_j\right\rVert/\bar{w}_c>1-\theta^2/2, \tag*{(21)}

that is, under the H\mathcal{H}-matrix admissibility criterion (Hackbusch, [38]; Sauter & Schwab, [77]) together with normal coherence; otherwise it opens the node, down to individual tokens. Here diam⁡(c)\operatorname{diam}(c) is the diagonal of the box of the node’s centroids, widened by a bound on rounding so that no tie of the criterion is decided by rounding, and dist⁡(xq,c)\operatorname{dist}(x_q,c) the distance from the query to that box. Within one tree all normals point to the same face of the cube, so in three dimensions the second condition always holds for θ>0.92\theta>0.92, and at θ=1\theta=1 only the first is active. Each query’s list covers every token exactly once, as itself or inside one accepted node. Each query traverses the trees independently: queries never form clusters with one another. At θ=1\theta=1 a query of a DrivAerML case has about 680 sources for 2×1052\times10^5 tokens. Only zeroth moments are stored, so the approximation is that of a monopole expansion whose “charges” are learned states. No gradient is propagated through the pair invariants, and a model is trained and evaluated at one θ\theta. With randomly initialized weights in float64, the outputs at θ=1\theta=1 deviate from those of the exact boundary read by 1.4 to 3.5% on two synthetic geometries, a sphere and a random point cloud. Trained models depend on their angle more strongly: evaluated with the exact boundary read, AirfRANS models trained at θ=1\theta=1 have 2.0 to 5.1 times their error (Section D.7).

Sizes and Training

Table 3 lists the reference configuration and the training recipe of the pose and discretization tests; the optimizers are Muon (Jordan et al., [47]) and AdamW (Loshchilov & Hutter, [57]). Each block has 5,449,991 parameters, of which the token MLP and the slice MLP account for 77%. The interior form adds the query input layer, the kernel basis, and twelve boundary reads (1,214,336 parameters in all). Under bfloat16 autocast, the query geometry, the tree, and the anchors’ mean normals are computed in float32, and so is the head when scales or output statistics are declared; the anchor positions follow autocast.

Table 3. Top: the reference configuration of ISLA, used on every dataset in this paper. Bottom: the training recipe of the pose and discretization tests. The recipes of AeroZoo, AirfRANS, and the automotive datasets differ from it in the loss, the learning rate, and the length of training (Section C).

Cost. Per block, the boundary side costs about 12.5NC2+5NMC12.5NC^2+5NMC multiply-adds for NN tokens: the dense maps dominate, the slice terms are a tenth of the total, and there is no term in N2N^2. A query costs (2.5+8)C2+2MC(2.5+8)C^2+2MC per layer for its slice read and MLPs, plus 224 multiply-adds per source for the boundary read. The boundary side runs once per case, and the query side is linear in the number of queries with no interaction among them.

Experimental Setup

Datasets

Table 4. The datasets. “Cases” counts the cases with released fields (the dataset papers describe 500 for DrivAerML and 355 for WindsorML), and the cell counts are per case, from the released files. DrivAerML stores polygons: split into triangles for the interior form of ISLA, the surface of a car has about 1.7×1071.7 \times10^{7} cells.

DatasetCasesWhat variesSimulationSurfaceVolume
AeroZoo ([81])3,815shape, enclosure, size, speed, ReRe (10310^{3} to 10810^{8}), orientationunsteady RANS, transition SST0.43 M (median)5.0 M (median)
AirfRANS ([18])1,000airfoil, angle of attack, ReReRANS (2-D)about 1,000about 179,000
DrivAerML ([8])484car shape (16 parameters)hybrid RANS-LES7.4 to 10.1 Mabout 142 M
WindsorML ([6])350Windsor-body shape (7 parameters)wall-modeled LES2.0 to 2.6 M271 to 330 M
AhmedML ([7])500Ahmed-body shape (6 parameters)hybrid RANS-LES0.7 to 1.5 M20 to 23 M

Table 4 lists the datasets. AeroZoo varies the shape (seven geometry families, no body used twice) and the enclosure, and with it the layout of the boundary conditions (eight configurations; 161 of the cases are ducts without a body). It also varies the size (0.02 to 20 m), the inlet speed (0.25 to 50 m/s), the Reynolds number, and the orientation of every case, which is random. Its inputs are the four boundary meshes of a case, by condition type (inlet, outlet, no-slip, slip), the values that each prescribes, and the fluid’s viscosity and density ([81]). AeroZoo calls a solved and released case a sample; we say “case” for every dataset and keep “sample” for a draw of cells. AirfRANS varies airfoil geometry, inlet direction, and speed in two dimensions, while the three road-vehicle datasets (DrivAerML, WindsorML, and AhmedML) hold one flow condition each, in one orientation, from one mesher, so their cases differ in shape only.

AeroZoo

Data. We use the interior task of AeroZoo release v1.2 (catalog SHA-256 c8e9508e8a9d8291...) ([81]), on its full split and on six of its splits that hold out a region (Table 11). Training, validation, and test use the canonical cases of a split, those whose time averages are converged (2,816 of the 3,815); on full these are 2,011 training, 290 validation, and 515 test cases. The flag that marks a case as canonical is computed from the solution and is not an input. As AeroZoo specifies, the two splits that hold out a geometry family are scored on test cases with a body.

Metrics. With cell volumes ViV_i, reference speed UrefU_{\mathrm{ref}}, and reference dynamic pressure qrefq_{\mathrm{ref}} of a case,

εU=1Uref(∑iVi∥u^i−ui∥2∑iVi)1/2,εp=1qref(∑iVi(p^i−pi)2∑iVi)1/2(22)\varepsilon_U = \frac{1}{U_{\mathrm{ref}}}\left(\frac{\sum_i V_i\lVert\hat{\mathbf{u}}_i-\mathbf{u}_i\rVert^2}{\sum_i V_i}\right)^{1/2}, \qquad\varepsilon_p = \frac{1}{q_{\mathrm{ref}}}\left(\frac{\sum_i V_i(\hat{p}_i-p_i)^2}{\sum_i V_i}\right)^{1/2} \tag*{(22)}

over every interior cell ([81]). The reference scales and the cell volumes are used by the scorer only. Results are medians and means over the canonical test cases; the mean is dominated by crossflow and dual-inlet cases. The free-stream reference predicts the mean prescribed inlet state everywhere and calibrates the metrics case by case; the zero predictor predicts zero velocity and gauge pressure. We also report the median over cases of the ratio of a model’s εU\varepsilon_U to the reference’s, and the share of cases on which the model’s is lower.

ISLA on AeroZoo. The four conditions are declared by name: the inlet with its prescribed velocity and turbulence quantities, the outlet with its pressure and reverse-flow values, and the no-slip and slip walls without data. The inlet velocity defines the velocity scale and the one global direction, the density is a declared scale, and the length unit is that of Equation (2). The only global scalar is log⁡10(UL/ν)\log_{10}(U L/\nu) minus its mean over the training cases, so the length by which coordinates are scaled reaches the model only through a Reynolds number built on it. Other dimensionless inputs and outputs are divided by constants fitted on the training cases. ISLA predicts all seven fields of the task (velocity, pressure, and five turbulence quantities). Training uses 200,000 interior points and 200,000 boundary tokens per case, for 250 epochs at the reference recipe’s default learning rate (3.75×10−43.75 \times10^{-4}) and schedule (5 epochs of linear warm-up and a cosine decay to 10−610^{-6}), with a per-case relative L2L^2 loss per field in which velocity has weight 3, four cases per step, and the final checkpoint. The same settings are used on all seven splits. The two models of Table 12 use a step schedule instead, with the learning rate divided by 10 after epochs 100 and 200. For scoring, the model predicts every interior cell in float32, with the one deterministic draw of boundary tokens that evaluation uses. The interior-only ISLA rows are means over 4 seeds on full and 2 seeds on the other six splits. The row “ISLA + boundary targets” (4 seeds, 67.5 M parameters: 67,493,495, adding three wall-shear output channels) is ISLA’s default AeroZoo training recipe: each step adds 200,000 boundary faces (queried 10−6L10^{-6}L off the face on the fluid side) and supervises boundary pressure, boundary velocity, and wall shear stress where no Dirichlet condition fixes them, at 1.46 times the training step time and unchanged interior inference.

Baselines on AeroZoo. The baseline rows of Table 8 are those of Sharpe et al. [81]: Transolver (9.0 M parameters) and GeoTransolver (27.6 M), both with 12 layers of width 256. Each appears without and with tokens that carry the boundary conditions, and with inputs in either SI units or per-case scales (a length, a speed, and a Reynolds number computed from each posed problem). As released, the two models take the coordinates of a point, its distance and direction to the no-slip faces, and the viscosity, so no inlet or outlet value reaches them. The boundary tokens are the faces of all four boundaries with their condition type and prescribed values. Each row is one seed, scored at its final checkpoint, on the same 515 test cases as ISLA. That paper trains every row in 3 settings (float32 with a cosine schedule, float32 with a step schedule, and bfloat16 with a step schedule) and prints the first for all rows, as Table 8 does. Over the settings, the best configuration’s median εU\varepsilon_U is 0.084 to 0.101 and its mean 0.253 to 0.294. With boundary tokens in SI units, the median is 0.173 in the printed setting and 0.98 to 0.99 in the other two. ISLA is larger (67.5 M parameters) and is the mean of 4 seeds.

Pose and Discretization Tests

Models. The tests of § 5.2 use single models, each trained on a dataset’s stored presentation without augmentation: ISLA with the configuration and recipe of Table 3; GeoTransolver with 12 layers of width 1,024 on the three surface flow tasks (143 M parameters, trained with 100,000 cells) and width 256 elsewhere (9 M parameters; 28 M with its local features on the DrivAerML volume task); and Transolver with 16 layers of width 512 (47 M parameters). Figure 1 and Table 7, Table 23 and Table 24 use the 9 M width-256 GeoTransolver on the surface task. The baselines use the same optimizer, batch, number of epochs, warm-up, and cosine schedule as ISLA (GeoTransolver uses a step schedule on the bracket lug and, in float32 with tuned field weights, on DrivAerML volume), a learning rate of 10−310^{-3}, and bfloat16. They take the coordinates of the sampled cells or points, centered on the case, the normals, the unit free-stream direction, and for volume points the stored signed distance and its gradient. ISLA takes the named boundaries of the whole domain: on DrivAerML, HiLiftAeroML, and SHIFT-SUV it therefore receives the tunnel or far-field boundaries as well as the body, which the baselines do not. Each model has four seeds on the three surface flow tasks and on DrivAerML volume (and ISLA on Tensile2d), and two seeds elsewhere. All models are evaluated in float32 at their final checkpoint.

SettingValue
Reference architecture
Width CC, blocks, slices MM512, 12, 128
MLP expansion; activation4; GELU
Routing temperature τ\tau10
Boundary token budget BB (interior)200,000
Boundary read8 heads, 16 kernel basis functions, opening angle θ=1\theta=1, leaves of 4
Parameters66,261,600 (surface form); 67,476,449 (interior; 67,490,930 on AeroZoo)
Training recipe
OptimizerMuon for matrices, AdamW for all other parameters; weight decay 10−410^{-4}
Learning rate3.75×10−43.75\times10^{-4}; warm-up over 5 epochs, then cosine decay to 10−610^{-6}
Length500 epochs (AeroZoo 250, DeepJEB++ 40)
Batchfour cases per step, one on each of four GPUs
LossHuber (δ=1\delta=1) on standardized targets, measure-weighted on surface tasks
Points per case and step200,000 surface cells; or 200,000 tokens and 200,000 query points
Precisionbfloat16 autocast in training; float32 in evaluation
Checkpointthe final one
Augmentation, gradient clipping, weight averagingnone

Table 3.

TaskModelStep time [s]Peak memory [GiB]GPU-hours / run
AirfRANSTransolver0.306236
AirfRANSGeoTransolver0.213927
AirfRANSISLA0.322538
DrivAerML surfaceTransolver0.276222
DrivAerML surfaceGeoTransolver0.397828
DrivAerML surfaceISLA0.165611
DrivAerML volumeTransolver0.276231
DrivAerML volumeGeoTransolver0.9811867
DrivAerML volumeISLA1.0612971

Table 7. Training cost of single models (Section C.3; GeoTransolver at width 256): time per optimizer step, peak allocated memory per GPU, and GPU-hours per run. ISLA’s blocks are compiled; the baselines run uncompiled, as released. Step time and memory are from earlier runs of the same models with another learning-rate schedule. The models differ in size (Section C.3).

Relative L2L^2 change of prediction ↓\downarrow
Surface task (DrivAerML, float32)
Change of presentationTransolver ppTransolver τw\tau_wGeoTransolver ppGeoTransolver τw\tau_wISLA ppISLA τw\tau_w
Rotation and translation1.21.61.21.46×10−46 \times10^{-4}10−310^{-3}
rotation alone1.11.61.11.44×10−44 \times10^{-4}10−310^{-3}
translation alone9×10−49 \times10^{-4}2×10−32 \times10^{-3}8×10−48 \times10^{-4}2×10−32 \times10^{-3}4×10−44 \times10^{-4}10−310^{-3}
Reflection1.21.51.11.36×10−46 \times10^{-4}2×10−32 \times10^{-3}
Lengths in millimeters, all inputs converted6×10−46 \times10^{-4}10−310^{-3}6×10−46 \times10^{-4}10−310^{-3}3×10−43 \times10^{-4}8×10−48 \times10^{-4}
Size ×2\times2 at the same ReRe0.650.660.620.6510−610^{-6}3×10−63 \times10^{-6}
Order of the cells5×10−75 \times10^{-7}7×10−77 \times10^{-7}8×10−78 \times10^{-7}10−610^{-6}2×10−62 \times10^{-6}4×10−64 \times10^{-6}
Every cell split in two coincident halves8×10−48 \times10^{-4}10−310^{-3}7×10−47 \times10^{-4}9×10−49 \times10^{-4}4×10−64 \times10^{-6}8×10−68 \times10^{-6}
Cells drawn by area (on shared cells)0.280.330.290.356×10−36 \times10^{-3}0.010
redrawn by the same law (on shared cells)3×10−33 \times10^{-3}4×10−34 \times10^{-3}4×10−34 \times10^{-3}6×10−36 \times10^{-3}7×10−37 \times10^{-3}0.010
Last-bit move of every coordinate10−310^{-3}3×10−33 \times10^{-3}10−310^{-3}2×10−32 \times10^{-3}5×10−45 \times10^{-4}10−310^{-3}
Interior tasks (ISLA, float32)
Change of presentationDrivAerML, interior UUDrivAerML, interior ppAeroZoo UUAeroZoo pp
Rotation and translation6×10−36 \times10^{-3}4×10−34 \times10^{-3}10−310^{-3}2×10−32 \times10^{-3}
with the token draw held fixed10−310^{-3}6×10−46 \times10^{-4}10−410^{-4}3×10−43 \times10^{-4}
Reflection7×10−37 \times10^{-3}5×10−35 \times10^{-3}––
Lengths in millimeters, all inputs converted5×10−35 \times10^{-3}3×10−33 \times10^{-3}2×10−42 \times10^{-4}4×10−44 \times10^{-4}
Size ×2\times2 at the same ReRe2×10−62 \times10^{-6}2×10−62 \times10^{-6}4×10−74 \times10^{-7}6×10−76 \times10^{-7}
Order of the cells and of the query points10−310^{-3}10−310^{-3}6×10−76 \times10^{-7}2×10−62 \times10^{-6}
Every cell split in two coincident halves0.0140.0117×10−37 \times10^{-3}0.023
Another token draw of the same budget0.0140.0110.0100.025
Last-bit move of every coordinate5×10−35 \times10^{-3}0.0228×10−48 \times10^{-4}10−310^{-3}
10,000 points alone or among 200,0000000
10,000 points in ten chunks9×10−79 \times10^{-7}6×10−76 \times10^{-7}4×10−74 \times10^{-7}5×10−75 \times10^{-7}

Table 23. Measured invariances in float32: relative change of each trained model’s own prediction under each change of presentation (pp: pressure; τw\tau_w: wall shear stress; UU: velocity), as medians over 8 cases, where 1 is a change as large as the prediction. The last two rows test query independence. Dash: not measured.

ModelParametersInference, float32 time [s]Inference, float32 peak mem. [GiB]Inference, bfloat16 time [s]Inference, bfloat16 peak mem. [GiB]
Transolver47.2 M0.5616.30.1365.8
GeoTransolver9.0 M0.2135.40.0925.1
ISLA66.3 M0.3686.40.0844.0
ISLA, blocks compiled66.3 M0.3213.40.0502.7

Table 24. Time and memory of one prediction for 200,000 surface cells of a DrivAerML car on one GPU (median of five calls; peak allocated memory). The baselines are the Transolver of § 5.2 and the 9 M width-256 GeoTransolver of Figure 1 (Section C.3), uncompiled, as released. ISLA is shown uncompiled and with each of its blocks compiled, as it is trained and evaluated.

Data and metric. On AirFRANS we use the 800 training and 200 evaluation cases of its full task, with 100,000 points per case. On DrivAerML we use 435 training and 48 evaluation cases (one of its 484 cases is in neither set), with 200,000 cells or points per case (Transolver is trained with 100,000 and evaluated with 200,000). We also report the tests on HiLiftAeroML (Ashton et al., [9]) and SHIFT-SUV (Luminary Cloud, [59]), and on three solid-mechanics datasets to which the same models apply unchanged: Tensile2d (Casenave et al., [27]), the bracket lug of Liu et al. [56], and DeepJEB++ (Yoo et al., [96]). Figure 8 shows one field per task: velocity on the two interior flow tasks, pressure on the three surface tasks, stress on Tensile2d and the lug, and displacement on DeepJEB++. Table 19 gives every field. The metric is the relative L2L^2 error of a field over the scored cells or points of a case, weighted by cell measure on surfaces and unweighted over the sampled points of an interior task, averaged over cases and then over seeds. Every model is scored on the same cells of each case. The tests compare each model with itself in another presentation; the baselines here are single networks rather than the ensembles of § 5.4 (Table 21 repeats the DrivAerML tests on tuned ensemble members).

TaskFieldRelative L2L^2 error as stored [%] ↓ TransolverRelative L2L^2 error as stored [%] ↓ GeoTransolverRelative L2L^2 error as stored [%] ↓ ISLAError (rotated, translated) ÷ stored TransolverError (rotated, translated) ÷ stored GeoTransolverError (rotated, translated) ÷ stored ISLA
AirfRANSpressure0.8880.9790.8311341581.004
velocity2.823.550.41144321.004
eddy viscosity1.701.681.5887861.000
DrivAerML surfacepressure4.134.004.0229311.000
wall shear6.676.556.4821201.000
DrivAerML volumepressure4.683.493.8217241.000
velocity9.094.745.2714241.000
eddy viscosity8.348.077.7618241.001
HiLiftAeroML surfacepressure5.295.165.3719211.011
wall shear8.968.779.0914151.007
SHIFT-SUV surfacepressure4.013.834.0330371.000
wall shear6.266.166.2818191.000
Tensile2dstress0.6150.4540.5171552411.004
displacement0.4600.3270.4122624021.003
Bracket lugvon Mises stress0.1980.2240.1935044151.005
DeepJEB++ surfacevon Mises stress39.941.737.93.24.81.000
displacement14.815.414.69.7131.000

Table 19. Pose and discretization tests, rigid motion, on every task and field: each model’s relative L2L^2 error in percent on the cases as stored, and its error on the rotated and translated cases divided by that error (seed means, float32; Section C.3).

Pose. Each case receives one rotation, uniform on SO(3)\mathrm{SO}(3) (in the plane for two-dimensional problems), and a translation by one root-mean-square radius of its points, both fixed by the case’s identifier. Positions, normals, global vectors, and vector and tensor targets are transformed together, and predictions are compared with the transformed targets. The data pipelines of the automotive, wing, and DeepJEB++ datasets center each case on the mean of its points, which removes the translation before any model receives it; on AirFRANS, Tensile2d, and the bracket lug the translation reaches every model.

Re-sampling. From a pool of 10610^6 cells drawn uniformly, each cell is kept independently with probability proportional to its area, for an expected 200,000 cells, and is weighted by its measure divided by its inclusion probability. ISLA uses the cells with these measures; the baselines use the same cells’ centroids and normals. The metric uses the same weights for every model. This test applies where a surface has more cells than a model receives (DrivAerML, HiLiftAeroML, SHIFT-SUV).

AirfRANS

On AirfRANS we use the three splits and node-level evaluator defined by FluidsBench [32] (Table 5): full and scarce, with the same 200 test cases, and aoa_extrapolation, whose test angles of attack lie outside the training range. AirfRANS defines 800 official training cases on full and 804 on aoa_extrapolation, with no separate validation list; we hold out 80 official training cases for validation (using the same 80 on scarce, whose 200 training cases do not contain them, and 80 of its own on aoa_extrapolation), and 6 of the 17 members of ISLA’s full test entry (and 6 of 13 on aoa_extrapolation) train on all 800 or 804 official training cases, with a fixed schedule and the final checkpoint (excluded from the 80-case validation rows of Table 13).

SplitAirfRANSDrivAerMLWindsorMLAhmedML
full720 / 80 / 200400 / 34 / 50280 / 35 / 35400 / 50 / 50
medium—133 / 34 / 5093 / 35 / 35133 / 50 / 50
scarce200 / 80 / 20067 / 34 / 5047 / 35 / 3567 / 50 / 50
super_scarce—11 / 34 / 508 / 35 / 3511 / 50 / 50
out of distribution724 / 80 / 196 (one)339 / 48 / 97243–244 / 35–36 / 70–71350 / 50 / 100

Table 5. Splits of AirfRANS and the automotive aerodynamics datasets (defined by FluidsBench [32]): numbers of training / validation / test cases. The last row gives the counts of each out-of-distribution split (one on AirfRANS, four on each automotive dataset). Dash: the dataset has no such split.

Split (train)CasesnnModelpsp_sτw\tau_wu\mathbf{u}pvp_vCdC_dClC_l
full (720)validation80Transolver1.221.840.561.260.9741.000
GeoTransolver1.341.520.501.270.9701.000
GLOBE0.370.570.160.340.9971.000
ISLA0.570.610.270.570.9931.000
full (720)test200Transolver1.171.760.531.140.8991.000
GeoTransolver1.201.460.471.090.9241.000
GLOBE0.340.550.150.280.9911.000
ISLA0.550.570.300.570.9581.000
scarce (200)validation80Transolver3.463.041.243.910.1000.999
GeoTransolver3.182.801.113.460.5940.999
GLOBE1.031.040.381.050.8961.000
ISLA1.551.710.762.130.7431.000
scarce (200)test200Transolver2.992.841.113.250.4700.999
GeoTransolver2.872.671.042.910.5570.999
GLOBE0.860.980.320.750.9191.000
ISLA1.541.700.761.960.5090.999
aoa_extrapolation (724)validation80Transolver0.821.200.390.950.8301.000
GeoTransolver0.981.270.431.030.7861.000
GLOBE0.300.540.120.250.9921.000
ISLA0.520.620.210.460.9531.000
aoa_extrapolation (724)test196Transolver8.316.443.8412.21−0.0670.998
GeoTransolver9.296.603.9113.020.3550.996
GLOBE1.942.140.983.870.7931.000
ISLA2.582.671.374.550.6521.000

Table 13. AirfRANS: every split (training cases in parentheses), on validation and test cases. nn: evaluated cases. psp_s and τw\tau_w: surface pressure and wall shear stress; u\mathbf{u} and pvp_v: volume velocity and pressure; CdC_d and ClC_l: the R2R^2 of the drag and lift coefficients. Bold: the lowest error and the highest R2R^2 among the four families where all four are evaluated. Dash: not evaluated.

An entry predicts velocity and pressure at every mesh node of each test case, and the evaluator derives the wall quantities and integrates the drag and lift coefficients (R2R^2 over cases). Each family’s entry is an ensemble (Table 6): on full, ISLA’s entry averages 17 networks of 67 M parameters and GLOBE’s averages five of 1.1 M; Transolver and GeoTransolver blend two kinds of member by wall distance. ISLA takes the airfoil and the free stream and predicts a wall-scaled velocity, Transolver and GeoTransolver predict through a form that vanishes on the wall, and GLOBE predicts a disturbance of the free stream.

SettingTransolverGeoTransolverGLOBEISLA
AirfRANS (full, aoa_extrapolation, scarce)
Networks3, 20, 159, 9, 95, 4, 717, 13, 6
Parameters9 M9 M and larger1.1 M (two of 0.3 M)67 M
DrivAerML
Networks (S+VS+V)5+5 (full: 5+10)5+5 (full: 10+5)3+35 (full: 9), each a joint surface and volume network
Layers ×\times width16 ×\times 76812 ×\times 768 or 12 ×\times 512 (SS), 12 ×\times 256 (VV)–12 ×\times 512
Parameters106 M80 M or 36 M (SS), 28 M (VV)12 M67 M
Training points100,000200,00050,000200,000 (SS) and 200,000 (VV)
Learning rate10−310^{-3}10−310^{-3}3×10−33 \times10^{-3}7.5×10−47.5 \times10^{-4}
Optimizer steps50,000 on every split50,000 on every split60,000 / 28,800 / 4,80050,000 on every split
WindsorML
Networks (S+VS+V)6+6 (super_scarce: 3+3)3+33+32 to 5 (SS), 2 to 5 (VV)
Parameters7 M18 M4 M66 M (SS), 67 M (VV)
Training points200,000200,00040,000200,000
Learning rate10−310^{-3} or 2×10−32 \times10^{-3}3×10−33 \times10^{-3}3×10−33 \times10^{-3}3.75×10−43.75 \times10^{-4} (SS), 7.5×10−47.5 \times10^{-4} (VV)
AhmedML
Networks (S+VS+V)3+3 or 3+43+3 or 3+43+3, 4+3, or 3+42+2 to 3+8
Parameters47 M36 M (SS), 28 M (VV)1 M66 M (SS), 67 M (VV)
Training points100,000200,000 (SS), 100,000 (VV)80,000200,000
Learning rate10−310^{-3}10−310^{-3}10−210^{-2}3.75×10−43.75 \times10^{-4} (SS), 7.5×10−47.5 \times10^{-4} (VV)
Optimizer steps50,000 on every split50,000 on every split50,000 on every split50,000 on every split

Table 6. Ensemble entries on AirfRANS and the automotive aerodynamics datasets (Table 2 and Table 14). “S+VS+V” is the number of surface and volume networks in an entry; where entries differ between the splits of a dataset, the table lists the sizes that occur. Parameters are per network. Learning rates are peak values. Optimizer steps are those scheduled, for full / scarce / super_scarce. A dash: does not apply.

Automotive Aerodynamics Datasets

On DrivAerML, WindsorML, and AhmedML we use the splits and evaluators defined by FluidsBench [32]. We report the evaluator’s field errors and R2R^2 values.

Splits. Each road-vehicle dataset has eight splits (Table 5): four share one validation and one test list and differ in the number of training cases (full, medium, scarce, and super_scarce), and four hold out a region for testing: the cases farthest from the others in shape (geometry), the highest or lowest drag (high_drag, low_drag), and the largest wake or rear separation, measured on published images (rear_separation on DrivAerML, image_wake on WindsorML and AhmedML). On AhmedML the validation cases of these four splits are drawn from the training-side population, so validation errors there do not show the shift of the test cases.

Entries and metrics. An entry predicts pressure and wall shear stress at every surface cell and velocity and pressure at every volume cell of the reference mesh of each test case; force coefficients are integrated by the evaluator from the predicted fields. All entries are trained from scratch on the official training cases of their split. For each case the evaluator computes the relative L2L^2 error of each field over all evaluated entities, weighted by face area on the surface and equally per cell in the volume, and averages it over cases, alongside the R2R^2 of drag and lift.

Model families. We trained all four families ourselves, using the released PhysicsNeMo implementations of Transolver, GeoTransolver, and GLOBE (PhysicsNeMo Contributors, [67]) and the ISLA architecture of Table 3. Each entry is the equal-weight mean of independently trained member networks, taken separately for the surface and volume (Table 6), with member count, recipe, and inputs tuned per family and dataset:

  1. Size. On DrivAerML one ISLA network predicts the surface and the volume; on its full training set the entries hold 0.61 (ISLA, nine networks), 0.72 (GeoTransolver, fifteen), and 1.59 (Transolver, fifteen) billion parameters. On WindsorML

and AhmedML every family trains separate surface and volume networks, and ISLA’s networks and entries are the largest.

  1. Inputs. Transolver and GeoTransolver take the coordinates and normals of the sampled cells, the free-stream direction, and for volume points a stored signed distance to the body. GLOBE takes the body and, on DrivAerML and WindsorML, patches of the floor and tunnel as boundary sources. ISLA takes the named boundaries of the whole domain (the body and the tunnel’s inlet, outlet, floor, and walls) and no coordinates, computing boundary distance itself (Section B.6).

  1. Loss. ISLA trains on a per-case relative L2L^2 loss, and the baselines on a Huber loss of standardized fields.

  1. Budget and checkpoint. Every Transolver, GeoTransolver, and ISLA network trains for at least 50,000 optimizer steps with a cosine schedule (as does GLOBE on AhmedML; GLOBE on DrivAerML and WindsorML uses its earlier shorter-schedule runs on the smaller splits, Table 6). On DrivAerML the baselines are entered at the saved checkpoint with the lowest validation error, and ISLA (and all AhmedML lineups) at the final checkpoint.

  1. Augmentation and precision. No family was trained with rotations or translations. Transolver and GeoTransolver are trained in float32 on DrivAerML and in bfloat16 elsewhere; GLOBE and ISLA are trained in bfloat16.

Dataset notes. WindsorML. No model has test results, because the official evaluator does not read the released volume files. The validation results use our reader of those files with the official reduction. WindsorML stores an absolute volume pressure of about 37 kPa, so the relative error of volume pressure is only 0.05 to 0.22% for every model. Its official lists contain six pairs of cases with identical geometry, some of which lie on both sides of a split. On WindsorML, Transolver (all splits), GeoTransolver (all splits), and ISLA (full) use lineups retrained to at least 50,000 steps per network, while the other cells show the earlier lineups.

AhmedML. On image_wake and high_drag, the field errors of Transolver, GeoTransolver, and GLOBE on test cases are 3.0 to 11.1 and 1.6 to 3.1 times those on validation cases; this is the shift that those splits are built to contain. ISLA’s full entry has three surface and eight volume networks, the latter trained with five variants of the recipe; its validation entries on high_drag and low_drag were not evaluated per field.

Compute

All models were trained on nodes with four NVIDIA GB300 or GB200 GPUs, with one case per GPU per step on the three-dimensional datasets. One ISLA model on AeroZoo full takes 105 GPU-hours, at 0.66 s per step and 142 GiB per GPU; Table 7 gives the training cost of single models on AirfRANS and DrivAerML (Section C.3). A later version of the code recomputes some activations of the compiled blocks in the backward pass instead of storing them. On AeroZoo (measured over the second and third epochs), it lowers the peak allocated memory per GPU from 120.5 to 83.3 GiB and the time per iteration from 0.65 to 0.56 s (over a full 250-epoch AeroZoo run, the largest-epoch peak drops from 142.2 to 105.4 GiB and the median step time from 0.66 to 0.56 s). Over epochs 2 and 3, it lowers peak memory from 25.3 to 17.6 GiB on AirfRANS, from 55.9 to 41.7 GiB on the DrivAerML surface, and from 129.0 to 93.3 GiB on its volume, while iteration time changes by at most 2% on these tasks. The joint surface-and-volume DrivAerML networks of Section C.5 cost more.

Additional Results

AeroZoo: Every Model and Split

Table 8 gives every model on full, and Table 9 the medians by enclosure configuration. ISLA’s median relative L2L^2 errors over the interior points, counted equally, are 0.103 for velocity and 0.321 for gauge pressure, and its median errors within one reference length of the body are 0.091 and 0.043. The mean pressure error of every model is set by a few cases: ISLA’s mean εp\varepsilon_p is 0.298 and its median 0.023. Supervising boundary targets as well lowers mean εp\varepsilon_p to 0.171 (median 0.021, and relative L2L^2 pressure error 8% lower), while turbulence metrics remain unchanged within noise. ISLA also predicts the five turbulence fields of the task (Table 10). For the intermittency and the transition Reynolds number we report its median relative L2L^2 errors, 0.016 and 0.085, in place of AeroZoo’s own metrics.

Table 9. AeroZoo, full: median εU\varepsilon_U by enclosure configuration, the numbers behind Figure 4. “BC”: with boundary tokens; “scaled”: in per-case scales. Baseline rows are from Sharpe et al. [81]; its rows in SI units without boundary tokens are at the zero predictor’s value in every configuration and are omitted. Bold: the lowest error in each column.

Model (test cases)Sphere (63)Open box (95)Ground effect (107)Confined box (59)Hemisphere (29)Duct (41)Crossflow (34)Dual inlet (87)
Free-stream reference0.0340.0430.0740.1590.1940.5100.9691.513
Transolver, scaled1.2360.0830.0910.1621.5780.4430.9721.118
GeoTransolver, scaled1.0760.4290.3900.4271.2800.5311.2001.607
GeoTransolver + BC, SI0.0780.0910.1130.2020.2040.5420.9471.516
GeoTransolver + BC, scaled0.0310.0570.0580.1170.1140.3100.3961.124
ISLA0.0230.0280.0430.0900.0520.1380.1240.143

Table 9.

Table 10. AeroZoo, full: median errors of three turbulence fields, in the units that AeroZoo defines (Uref2U_{\mathrm{ref}}^2, Uref/LrefU_{\mathrm{ref}}/L_{\mathrm{ref}}, and UrefLrefU_{\mathrm{ref}}L_{\mathrm{ref}}). The reference’s errors give their scale. Bold: the lowest error in each column.

ModelMedian ref.-scaled error εk\varepsilon_kMedian ref.-scaled error εω\varepsilon_\omegaMedian ref.-scaled error εvt\varepsilon_{v_t}
Free-stream reference0.005735.60.0013
GeoTransolver + BC, per-case scales0.004319.60.00070
ISLA0.00305.810.00036

Table 10.

Table 11 gives ISLA’s errors on every AeroZoo split that we trained. With a geometry family held out, the median velocity error on cases with a body is 0.059 (blobs) and 0.079 (CAD parts), compared with 0.053 over all test cases of full. With the Reynolds numbers above 10610^6 held out, the median velocity error (0.067) is close to the reference’s (0.076), while the mean (0.125) is three times lower than the reference’s (0.379). With a layout of the boundary conditions held out (profile_crossflow, profile_dual_inlet), ISLA’s median εU\varepsilon_U is 31 and 11% below the reference’s. With every non-box enclosure held out, ISLA is as little less accurate than the reference in both fields. We have no baseline with per-case scales on these splits.

Table 12 compares an ISLA of about GeoTransolver’s size with one of the reference size, both trained on the same step schedule (Section C.2). The smaller one has 8 blocks, 64 slices, an MLP ratio of 2, and 10510^5 boundary tokens per case in place of 2×1052 \times10^5, so it reduces the token budget as well as the parameters. On full its errors are within 3% of the larger model’s, and its mean εU\varepsilon_U is 3% higher. With every non-box enclosure held out (family_non_box), its mean εU\varepsilon_U is 1.17 times the larger model’s.

AirfRANS

Table Table 13 gives every field error and R2R^2 value on all three AirfRANS splits (defined by FluidsBench; [32]), on validation and test cases. Bold marks the lowest error and the highest R2R^2 among the four families, and a dash a value that does not exist.

Table 13. AirfRANS: every split (training cases in parentheses), on validation and test cases. nn: evaluated cases. psp_s and τw\tau_w: surface pressure and wall shear stress; u\mathbf{u} and pvp_v: volume velocity and pressure; CdC_d and ClC_l: the R2R^2 of the drag and lift coefficients. Bold: the lowest error and the highest R2R^2 among the four families where all four are evaluated. Dash: not evaluated.

Automotive Aerodynamics Datasets

Table Table 14 compares ISLA with the lowest of the other three families on the main splits of DrivAerML, WindsorML, and AhmedML (using the splits defined by FluidsBench; [32]), and Table 15 to Table 17 give every field error and R2R^2 value for every split. With WindsorML’s 8 training cases ISLA’s errors differ from the lowest other’s by −3 to +24%, and with AhmedML’s 11 by −7 to +12%. Figure 7 plots the surface-pressure and volume-velocity errors as functions of the number of training cases on the three automotive datasets.

Figure 7. Surface-pressure and volume-velocity errors as functions of the number of training cases on the three automotive datasets (relative L2L^2, logarithmic axes). Lines and filled markers: validation cases. Open markers: test cases, where an entry has test results; none has on WindsorML.

Split (train)CasesnnModelpsp_sτw\tau_wuupvp_vCdC_dClC_l
full (400)validation34Transolver3.725.924.563.210.9900.992
GeoTransolver3.605.704.433.110.9920.992
GLOBE7.678.677.365.890.9590.980
ISLA3.675.984.833.280.9930.993
full (400)test50Transolver––––––
GeoTransolver––––––
GLOBE7.348.317.375.820.9650.970
ISLA3.365.584.803.230.9880.982
medium (133)validation34Transolver4.316.785.423.980.9820.982
GeoTransolver4.306.775.193.790.9840.981
GLOBE8.909.898.416.790.9580.944
ISLA4.417.035.744.100.9800.982
medium (133)test50Transolver––––––
GeoTransolver––––––
GLOBE8.519.408.396.580.9540.924
ISLA4.126.636.004.110.9800.967
scarce (67)validation34Transolver5.167.856.554.960.9690.948
GeoTransolver5.037.666.224.640.9620.957
GLOBE9.3911.289.357.560.9300.924
ISLA5.217.987.035.180.9550.945
scarce (67)test50Transolver––––––
GeoTransolver––––––
GLOBE9.0710.819.437.410.9680.912
ISLA4.977.667.335.090.9680.917
super_scarce (11)validation34Transolver14.1116.7714.5112.620.5000.188
GeoTransolver14.4717.3814.5912.860.5460.334
GLOBE17.8021.2616.8014.700.5050.449
ISLA12.2915.4413.2311.450.7430.530
super_scarce (11)test50Transolver––––––
GeoTransolver––––––
GLOBE17.1420.1116.4114.060.694-0.015
ISLA11.2914.0312.6510.450.7290.186
geometry (339)validation48Transolver3.245.344.523.110.9920.978
GeoTransolver3.145.224.372.990.9940.983
GLOBE7.288.327.456.000.9760.964
ISLA3.305.554.913.310.9920.980
geometry (339)test97Transolver––––––
GeoTransolver––––––
GLOBE8.119.658.346.660.9530.978
ISLA4.206.856.204.280.9870.989
high_drag (339)validation48Transolver3.505.614.393.010.9890.988
GeoTransolver3.465.534.332.960.9900.985
GLOBE7.668.617.585.940.9660.968
ISLA3.555.724.743.130.9910.986
high_drag (339)test97Transolver––––––
GeoTransolver––––––
GLOBE8.449.848.436.860.8680.941
ISLA4.086.575.724.150.9430.975
low_drag (339)validation48Transolver3.535.754.573.090.9900.984
GeoTransolver3.495.694.452.990.9880.983
GLOBE7.718.757.325.840.9580.958
ISLA3.575.904.933.340.9910.983
low_drag (339)test97Transolver––––––
GeoTransolver––––––
GLOBE8.209.628.596.680.9640.952
ISLA4.337.077.044.910.9740.974
rear_separation (339)validation48Transolver3.585.634.553.230.9910.983
GeoTransolver3.555.544.413.140.9920.985
GLOBE7.748.657.566.070.9670.950
ISLA3.695.884.923.460.9910.986
rear_separation (339)test97Transolver––––––
GeoTransolver––––––
GLOBE7.668.787.916.240.9630.943
ISLA3.786.135.593.810.9880.960

Table 15. Table 15. DrivAerML: every split (training cases in parentheses). Columns, bold, and dashes as in Table 13. On DrivAerML, Transolver (all splits) and GeoTransolver (all splits) use lineups retrained to at least 50,000 steps per network (matching ISLA’s 50,000-step lineups), while GLOBE shows its earlier lineups.

Split (train)CasesnnModelpsp_sτw\tau_wuupvp_vCdC_dClC_l
full (400)validation50Transolver3.595.571.803.250.9610.951
full (400)validation50GeoTransolver3.345.361.793.220.9630.975
full (400)validation50GLOBE3.755.272.524.040.8420.892
full (400)validation50ISLA3.075.152.323.550.9680.960
full (400)test50Transolver3.415.351.713.230.9210.919
full (400)test50GeoTransolver3.355.361.733.210.9320.925
full (400)test50GLOBE3.685.132.434.040.8670.896
full (400)test50ISLA2.954.972.183.200.9270.915
medium (133)validation50Transolver3.765.562.103.660.9740.947
medium (133)validation50GeoTransolver3.555.372.153.710.9820.954
medium (133)validation50GLOBE3.535.142.574.250.9330.952
medium (133)validation50ISLA3.135.232.393.540.9760.959
medium (133)test50Transolver4.085.332.164.060.6980.823
medium (133)test50GeoTransolver3.735.132.164.000.7750.869
medium (133)test50GLOBE3.735.202.674.470.8710.881
medium (133)test50ISLA3.435.252.373.570.8920.919
scarce (67)validation50Transolver4.786.222.905.000.8920.907
scarce (67)validation50GeoTransolver4.746.192.975.060.8770.897
scarce (67)validation50GLOBE4.755.353.045.400.9040.902
scarce (67)validation50ISLA4.165.822.914.860.9410.941
scarce (67)test50Transolver4.865.902.434.270.4160.584
scarce (67)test50GeoTransolver5.015.902.484.410.4240.578
scarce (67)test50GLOBE4.085.212.724.670.8510.856
scarce (67)test50ISLA4.335.542.564.110.6310.720
super_scarce (11)validation50Transolver9.208.195.3511.010.5600.754
super_scarce (11)validation50GeoTransolver8.257.735.3111.460.6940.756
super_scarce (11)validation50GLOBE9.057.326.3010.590.7210.675
super_scarce (11)validation50ISLA8.107.614.489.430.7530.798
super_scarce (11)test50Transolver9.669.055.1910.270.0960.370
super_scarce (11)test50GeoTransolver8.968.585.2910.750.3260.384
super_scarce (11)test50GLOBE8.467.765.658.780.5370.504
super_scarce (11)test50ISLA8.498.124.809.840.5500.604
geometry (350)validation50Transolver3.255.081.803.420.9330.951
geometry (350)validation50GeoTransolver3.265.131.803.470.9190.936
geometry (350)validation50GLOBE4.005.112.604.520.7230.814
geometry (350)validation50ISLA3.215.082.383.640.9030.921
geometry (350)test100Transolver3.925.502.183.690.9380.868
geometry (350)test100GeoTransolver3.885.442.173.680.9410.876
geometry (350)test100GLOBE4.005.272.974.600.9410.870
geometry (350)test100ISLA––––––
high_drag (350)validation50Transolver2.854.811.683.220.8520.947
high_drag (350)validation50GeoTransolver2.734.881.683.210.8900.963
high_drag (350)validation50GLOBE2.814.542.173.620.8880.946
high_drag (350)validation50ISLA––––––
high_drag (350)test100Transolver8.747.644.719.51-1.5180.569
high_drag (350)test100GeoTransolver8.427.674.9110.10-1.3890.622
high_drag (350)test100GLOBE8.557.255.3110.50-1.4030.610
high_drag (350)test100ISLA––––––
low_drag (350)validation50Transolver3.865.641.963.370.5520.806
low_drag (350)validation50GeoTransolver3.725.461.983.420.6690.846
low_drag (350)validation50GLOBE3.464.892.654.100.9160.938
low_drag (350)validation50ISLA––––––
low_drag (350)test100Transolver3.014.741.402.840.5340.913
low_drag (350)test100GeoTransolver2.854.581.362.740.6430.943
low_drag (350)test100GLOBE3.334.622.294.370.3200.882
low_drag (350)test100ISLA––––––
image_wake (350)validation50Transolver2.444.981.362.330.9590.869
image_wake (350)validation50GeoTransolver2.384.961.332.270.9590.880
image_wake (350)validation50GLOBE2.214.392.012.800.9540.878
image_wake (350)validation50ISLA2.044.811.892.260.9680.899
image_wake (350)test100Transolver22.1015.0211.4225.87-0.552-10.153
image_wake (350)test100GeoTransolver22.0115.0811.0725.22-0.535-9.917
image_wake (350)test100GLOBE21.8715.0010.5223.94-0.630-9.600
image_wake (350)test100ISLA––––––

Table 17. AhmedML: every split (training cases in parentheses). Columns, bold, and dashes as in Table 13.

One network per family. Table 18 gives the field errors of one network of each family, the first seed of its entry, beside those of the entry, on validation cases (Table 6 lists network sizes and schedules). A single network’s errors differ from its entry’s by −2% to +13%.

Table 18. One network per family beside the family’s entry: relative L2L^2 errors in percent on validation cases (first seed of each entry; ISLA on DrivAerML is one joint surface-and-volume network, evaluated in bfloat16 on full). On DrivAerML the baseline networks use the saved checkpoint with lowest validation error, and all others use their final checkpoint.

Relative L2L^2 error [%] ↓\downarrow
DatasetSplit (train)Field
One networkEntry (ensemble)
DatasetSplit (train)FieldTransolverGeoTransolverGLOBEISLATransolverGeoTransolverGLOBEISLA
AhmedMLfull (400)psp_s3.723.433.973.273.593.343.753.07
AhmedMLfull (400)τw\tau_w5.765.565.395.355.575.365.275.15
AhmedMLfull (400)uu1.781.882.782.501.801.792.522.32
AhmedMLfull (400)pvp_v3.203.424.593.873.253.224.043.55

Table 18. One network per family beside the family’s entry: relative L2L^2 errors in percent on validation cases (first seed of each entry; ISLA on DrivAerML is one joint surface-and-volume network, evaluated in bfloat16 on full). On DrivAerML the baseline networks use the saved checkpoint with lowest validation error, and all others use their final checkpoint.

On DrivAerML’s 11-case split, before the full entries were retrained to 50,000 steps, single networks of Transolver and GeoTransolver trained on an earlier 4,000-step schedule were also retrained on a schedule 12.5 times longer (50,000 steps scheduled, as for ISLA’s networks): stopped at 30,002 to 30,502 steps by that recipe’s learning-rate rule, with their best checkpoints at 4,502 to 10,002. Against controls trained beside them at the original length, the four field errors on validation cases fell by 31 to 36% and 12 to 26%, each with a 90% case-bootstrap interval below 1. Their errors then lay between 3% below and 11% above those of ISLA’s single network, against 22 to 72% above before, with surface pressure still 9 to 11% higher (the retrained networks’ checkpoints are chosen on these validation cases, while ISLA uses its final checkpoint).

Table 16. WindsorML: every split (training cases in parentheses), on validation cases only. Columns, bold, and dashes as in Table 13.

Split (train)CasesnnModelpsp_sτw\tau_wu\mathbf{u}pvp_vCdC_dClC_l
L2L^2 relative error [%] ↓\downarrow
Force R2R^2 ↑\uparrow
fullfull (280)validation35Transolver7.126.515.650.060.5820.939
GeoTransolver7.006.745.650.060.5830.941
GLOBE7.366.526.180.060.5710.944
ISLA6.616.465.380.060.6570.953
mediummedium (93)validation35Transolver8.097.126.700.070.4360.921
GeoTransolver8.097.216.960.080.4890.916
GLOBE8.467.077.320.080.3520.916
ISLA7.707.046.730.070.5660.930
scarcescarce (47)validation35Transolver9.298.117.820.100.1690.880
GeoTransolver9.868.447.790.10-0.1530.817
GLOBE9.237.738.000.09-0.1800.879
ISLA9.258.357.280.08-0.0610.867
super_scarcesuper\_scarce (8)validation35Transolver22.3916.2214.040.22-5.7050.343
GeoTransolver22.1615.9614.300.22-9.8650.435
GLOBE17.7012.6813.520.18-5.6830.220
ISLA21.0915.6713.140.20-7.4800.425
geometrygeometry (243)validation36Transolver7.786.635.700.060.6760.873
GeoTransolver7.887.095.740.060.6100.864
GLOBE7.896.626.170.070.4420.873
ISLA7.426.825.450.050.7960.946
high_draghigh\_drag (244)validation36Transolver6.855.915.760.050.7680.970
GeoTransolver6.935.926.100.060.7320.973
GLOBE7.006.156.050.060.6320.951
ISLA6.816.005.990.060.7500.972
low_draglow\_drag (244)validation36Transolver7.517.045.690.06-0.1010.948
GeoTransolver7.547.055.740.06-0.0270.953
GLOBE7.777.056.550.07-0.2400.953
ISLA7.086.975.860.060.0940.958
image_wakeimage\_wake (244)validation35Transolver8.066.976.480.080.8220.834
GeoTransolver8.027.196.640.080.8520.847
GLOBE7.746.566.670.070.7130.832
ISLA7.486.586.480.070.8580.848

Table 16. WindsorML: every split (training cases in parentheses), on validation cases only. Columns, bold, and dashes as in Table 13.

Pose and Discretization Tests: Every Field

Tables 19 and 20 give the numbers behind Figure 8, with every field of every task. A rotated case lies outside the training set of a model that takes coordinates, and the model’s error on it is then between 0.8 and 2.0 times that of predicting zero. The ratio in Table 19 is therefore of the order of one over the model’s error as stored, and it is largest on the tasks that are fitted best (the bracket lug, to 0.2%).

Table 21 repeats the DrivAerML surface tests with one network of each family’s DrivAerML full entry, on its validation cases. A rotation changes two inputs of Transolver and GeoTransolver at once: the geometry and the free-stream velocity, which is the same in every training case. The geometry causes the rise: with the free-stream input left as stored, the pressure error is still 27 to 29 times that on the stored cases. Moving each rotated case at inference into the vehicle’s area-weighted principal-axis frame (signs fixed by third central moments and right-handedness) lowers the pressure ratio only to 5.8 and 5.4, because a car’s principal axes tilt by about 2.3∘2.3^\circ from the stored frame. Adding one fixed alignment rotation fitted on the training cases reduces the residual rise to 9 and 18% in pressure and 12 to 19% in wall shear (inference only; canonicalization leaves re-sampling, units, query sets, and symmetric bodies untouched). Re-sampling by area multiplies their pressure errors by 7.6 to 9.0, and as many cells drawn uniformly leave them unchanged, so the rise comes from the law of the draw and not from the number of cells. GLOBE is equivariant by construction, yet the errors of its network rise by a factor of 1.19 to 1.26 under rotation and 1.07 to 1.10 under re-sampling. We have not identified the cause of either rise. The bottom block of Table 21 retrains one surface network each of Transolver and GeoTransolver with the pipelines’ vertical-axis rotation and ±1\pm1 m horizontal translation enabled (one seed; one random pose per four-GPU step; stopped near epoch 300 by the learning-rate rule). That augmentation removes the vertical-axis rotation rise (pressure ratio at most 1.001), leaves SO(3) rotation at 23 times stored and area re-sampling at 7.0 times, and multiplies stored-case errors by 1.13 and 1.23 in pressure (1.08 and 1.15 in wall shear).

Table 22 adds Transolver and GeoTransolver trained on rotations drawn uniformly over all orientations, the law of the rotated test, with the pipelines and schedules of the unaugmented seeds (2 seeds per augmented model). Their surface-pressure errors change by 0.1 and 0.2% under rotation, and are 4.5 and 3.3% higher on the stored cases than without augmentation. On the rotated cases they are 1.08 times ISLA’s (90% interval 1.03 to 1.12) and 1.03 times (0.99 to 1.07).

TaskFieldTransolverGeoTransolverISLA
DrivAerML surfacepressure7.23.61.005
wall shear5.63.31.010
HiLiftAeroML surfacepressure2.83.41.000
wall shear2.83.11.000
SHIFT-SUV surfacepressure1.511.370.999
wall shear1.391.231.000

Table 20. Pose and discretization tests, re-sampling by area: each model’s error on the re-sampled cases divided by its error on the cases as stored (seed means, float32), on the three tasks whose surfaces have more cells than a model receives.

Measured Invariances

Table 23 gives the relative change ∥back⁡(M(Tx))−M(x)∥/∥M(x)∥\lVert\operatorname{back}(M(Tx))-M(x)\rVert/\lVert M(x)\rVert of a trained model MM’s own float32 prediction when the same problem xx is given in another presentation TxTx. The norm is the measure-weighted L2L^2 norm over the evaluated cells or points, and “back” undoes TT on the output: vectors are rotated back, rows are put back in order, and units are converted back. Entries are medians over 8 evaluation cases of DrivAerML or test cases of AeroZoo, with 3 poses per case for rigid motions. TT acts on a case as the dataset stores it, before the data pipeline; the pipeline centers each DrivAerML case, so no model receives a pure translation there. With weights, inputs, and pipeline cast to float64, every exact invariance of Theorem 1 holds to at most 3×10−123 \times10^{-12} on the surface task, and query independence to at most 2×10−132 \times10^{-13} in the interior.

The surface task. In float32 a rigid motion moves its pressure by 6×10−46 \times10^{-4} and its wall shear stress by 10−310^{-3}. A move of every coordinate by one unit in its last place, at random up or down, moves them by as much (5×10−45 \times10^{-4} and 10−310^{-3}), and a rescaling that is exact in binary arithmetic (doubling) by 10−610^{-6}. The float32 rows therefore measure the rounding of the transformed input: where cells of less than a millimeter lie at coordinates of meters, their normals and areas change in the fourth digit. Transolver and GeoTransolver respond to the last-place move by 10−310^{-3} and 10−310^{-3}. A conversion of units in which every dimensional input and the dataset’s reference length are converted together leaves the baselines unchanged to the same rounding, because their data pipeline divides by that reference length. Doubling the geometry at a fixed Reynolds number, with the dataset’s constants left as they are, changes their predictions by 0.65 and 0.62.

When the cells are drawn by another law, the predictions can be compared on the cells that both draws contain. Between two draws from the dataset’s own law that share half of their cells, the predictions on the shared cells differ by 3×10−33 \times10^{-3} for Transolver, 4×10−34 \times10^{-3} for GeoTransolver, and 7×10−37 \times10^{-3} for ISLA. No model is exactly consistent between two samples, and ISLA is somewhat less so than the baselines. Between a draw from the dataset’s law and a draw by area, the differences are 0.28, 0.29, and 6×10−36 \times10^{-3}: ISLA’s is no larger than between two draws from the dataset’s law.

The interior tasks. Query independence is exact: a point predicted alone, or in other chunks, receives the same value to rounding. The other rows include the model’s own draw of 2×1052 \times10^{5} boundary tokens. On DrivAerML, a rigid motion in float32 changes 9% of the drawn tokens, through the rounding of the frame in which the cells are ordered, and the predicted velocity moves by 6×10−36 \times10^{-3}; with the draw held at that of the first presentation it moves by 10−310^{-3}. A last-bit move of every coordinate moves the predicted pressure by 2.2×10−22.2 \times10^{-2}, more than a rigid motion does: it flips the computed side of the boundary for about 710 of the 200,000 query points and turns the direction to the boundary by more than 0.1 rad at 0.4% of them. Splitting every cell changes which tokens are drawn (91% of them), because the budget is shared among the conditions by cell count, and moves the velocity by 1.4×10−21.4 \times10^{-2}, in float64 as in float32. This is the difference between two draws of the same budget (1.4×10−21.4 \times10^{-2}), which is the sampling error of 2×1052 \times10^{5} tokens for 1.7×1071.7 \times10^{7} cells. With a fixed budget this error does not vanish under refinement, so the interior form as run is consistent only up to it (Proposition 2). On AeroZoo, whose boundaries are smaller, a rigid motion changes few tokens and moves the velocity by 10−310^{-3}; across all 538 evaluation cases (290 of AeroZoo full, 200 of AirfRANS, and 48 of DrivAerML; Section C.3), zero cases hit an exact frame tie in float64, and on 128 near-degenerate AeroZoo validation cases across 5 float32 poses, mean ϵU\epsilon_U and ϵp\epsilon_p change by at most 0.05% (median per case 0.01%).

Cost and Scaling

Figure 9 and Table 24 and Table 25 give the cost of a prediction. Time and memory are linear in the number of surface cells for all three models above about 5×1045 \times10^{4} cells. Uncompiled, ISLA’s time lies between those of GeoTransolver and Transolver in float32 and below both in bfloat16 (Table 24 and Section C.3). For the interior task, the boundary side (the token draw, the twelve blocks, and the tree) takes 0.58 s in float32 and 0.32 s in bfloat16, once per case, and each million query points adds 3.3 s or 1.2 s. Query points are processed in chunks, so memory grows slowly: 10710^{7} points take 50 GiB. In a separate run, 10810^{8} points of one DrivAerML case, whose volume mesh has 1.4×1081.4 \times10^{8} cells, were predicted in 7 minutes at 72 GiB, and all 2.2 million cells of an AeroZoo case in 4.8 s. Table 7 in Section C.6 gives the cost of training.

Figure 9. Cost of one prediction as a function of problem size, on one GPU for one DrivAerML case. (a, b) The surface task, with every model uncompiled. (c) ISLA’s interior task with 2×1052 \times10^{5} boundary tokens: the boundary side is a fixed cost per case, and the rest is linear in the number of query points.

Query pointsInference, float32 time [s]Inference, float32 peak mem. [GiB]Inference, bfloat16 time [s]Inference, bfloat16 peak mem. [GiB]
10410^{4}0.63160.3516
10510^{5}0.96160.4716
10610^{6}3.98481.5731
10710^{7}33.755011.9932

Table 25. Time and memory of ISLA’s interior prediction for one DrivAerML case on one GPU, by the number of query points (2×1052 \times10^{5} boundary tokens drawn from 1.7×1071.7 \times10^{7} boundary cells; blocks compiled).

Ablations

For Table 26 we remove one design rule at a time and retrain the reference configuration with nothing else changed, on the DrivAerML surface task of the pose and discretization tests, and on AirfRANS for the boundary read (3 seeds for the first three variants and 2 for the last two). On DrivAerML each ratio divides by the mean of the reference’s 4 seeds, which lie within 3.3% of it; a fresh run of its first seed differs from that seed by 0.2%.

Counts in place of measures: within each boundary condition, every cell is given the condition’s mean measure, so that sums over tokens weight cells equally, as a model without quadrature weights does; the loss and the metric keep the true measures. The error on cells as stored is 0.5% lower, well inside the spread of the reference’s seeds. On cells re-sampled by area it is 43%, 11 times the reference’s.

Coordinates as inputs: the three coordinates of each cell’s centroid, centered and scaled as the baselines’ pipeline does, are added to the token’s input. The error on cases as stored is 3.6% lower than the reference’s (3 seeds), a difference near the spread of the reference’s seeds. On rotated cases it is 83%.

No relations to anchors: the relational invariants of Equation (5) are set to zero in every block, which removes all positional information from the boundary tokens. The error is 71% in every presentation.

Body alone as the boundary: the boundaries of the tunnel are removed from the input, so the model receives the car’s surface alone, and its length unit (Equation (2)) becomes that of the car. The error is 2% lower than the reference’s in every presentation, and both seeds of this variant lie within the range of the reference’s seeds. On this task the tunnel’s boundaries do not lower the error.

No boundary read: the read of Equation (9) is removed from the interior form, which leaves the slices as a query’s only access to the boundary. On AirfRANS the velocity error is 10% higher than the reference’s and the pressure error 8% higher, and the eddy-viscosity error is 8% lower. The reference’s two seeds lie within 2%, 4%, and 6% of their mean in these three fields. Both seeds of the variant lie outside that spread in velocity (ratios 1.07 and 1.13) and in eddy viscosity (0.92 and 0.93), but not in pressure (1.01 and 1.15). We have no fresh run of the AirfRANS reference.

Exact boundary read (θ=0\theta= 0): the AirfRANS interior model is trained and evaluated with the exact boundary read (θ=0\theta= 0) in place of the θ=1\theta= 1 tree (2 seeds). Its errors differ from the θ=1\theta= 1 reference’s by at most 0.9% across pressure, velocity, and eddy viscosity (well within the reference’s two-seed spread), at 2.7 times the training step time and 75 vs. 26 GiB per GPU.

The opening angle at inference. The trained weights depend on the tree. The two AirfRANS models of the pose and discretization tests, trained at θ=1\theta= 1, have 1.5 to 2.4 times their error when evaluated at θ=0.5\theta= 0.5, and 2.0 to 5.1 times with the exact boundary read (θ=0\theta= 0): 2.3 times in pressure, 2.0 in velocity, and 5.1 in eddy viscosity. On AeroZoo (8 validation cases of full, 2×1052 \times10^{5} points each), the two ISLA models trained at θ=1\theta= 1 deviate from their own exact boundary read (θ=0\theta= 0) by 2.5 and 2.8% in velocity and 7.2 and 7.3% in pressure (up to 14% on a single case, and 1.7% at θ=0.25\theta= 0.25; models trained and evaluated at θ=0.25\theta= 0.25 deviate by 1.4 and 1.6%), while their pressure error relative to the targets moves only from 27.3 and 28.3% at θ=1\theta= 1 to 28.4 and 29.1% at θ=0\theta= 0. A model must be evaluated at the angle at which it was trained, and the guarantees of the exact boundary read do not transfer to a model trained at another angle.

Additional Figures

Figure 10 shows what the slices of a trained model hold, layer by layer. Figure 11 and Figure 12 show interior predictions on AirfRANS and DrivAerML on a regular grid in place of the cells of the mesh. Figure 13 and Figure 14 show the fields of the ensemble entries on WindsorML and AhmedML.

The slices of a trained model across all 12 layers

Figure 10. What the slices of a trained model hold. All 12 layers of a trained ISLA on one DrivAerML case (run 171 of the dataset); Figure 3 shows layers 3, 6, and 12 larger. Each surface point has the color of the slice that receives the largest share of its weight. In each panel the eight slices that hold the most area have colors of their own, and all other slices are shades of gray; colors are unrelated between panels. The number in each panel counts the slices that hold some point. From layer 3 to layer 12 the slices go from broad bands to compact patches to sets scattered over the car (Section E). Anchors are not drawn: an anchor is a mean over its slice’s tokens and need not lie in or near the slice’s territory.

Figure 11. An AirfRANS evaluation case. Top: pressure coefficient, formed with the inlet dynamic pressure. Bottom: velocity magnitude over the inlet speed. Left: the reference, which exists only at mesh nodes, so it is drawn as a triangulation of the 100,000 scored nodes of this case and never across the airfoil; the nodes are a random subset of the mesh, which makes the thin wake look jagged. Middle: ISLA, evaluated on a regular grid of 1,000 by 600 points. Right: the difference, taken at the scored nodes, with its own and much finer color scale. The case has an inlet speed of 44.6 m/s, an angle of attack of −2.06∘-2.06^\circ, and a Reynolds number of 2.86×1062.86 \times10^{6}. Over its scored nodes, the relative L2L^2 error is 0.66% for pressure and 0.31% for velocity.

Figure 12. Figure 12. An interior field on a plane. ISLA predicts volume fields from the boundary surfaces alone (the car, the ground, and the tunnel), at any requested points. Here the points are a regular grid of 1,200 by 500 on the symmetry plane of one DrivAerML evaluation case (run 129 of the dataset), in place of the cells of its mesh. Rows: velocity magnitude over the free-stream speed in the reference (the stored cells within 16 mm of the plane, each grid point showing its nearest cell) and from ISLA, and the magnitude of their difference at the stored cells. The car’s section is gray, and the ticks give the streamwise coordinate. Bottom: the same three fields in the near wake (the outlined window). Over the 200,000 scored points of this case, the relative L2L^2 error is 5.5% for velocity and 4.0% for pressure.

Figure 13. Figure 13. WindsorML fields. What the ensemble entry predicts on a case it was not trained on: run 8 of WindsorML, a validation case of the full split. Top: the surface pressure coefficient cpc_p on the body, seen from behind. Bottom: the velocity magnitude over the reference speed UrefU_{\mathrm{ref}} (40 m/s) on the body’s center plane y=0y = 0, with the body’s outline; the window is three body lengths wide. The inflow is yawed by about 2.5 degrees, so this plane is not a symmetry plane of the flow. Left: the dataset’s time-averaged simulation. Right: the ISLA entry, which is the equal-weight mean of five surface networks and of five volume networks (Section C). ISLA predicts both fields from the boundary alone. The two columns share one color scale in each row.

Figure 14. Figure 14. AhmedML fields. What the ensemble entry predicts on a case it was not trained on: run 24 of AhmedML, a validation case of the full split. Top: the surface pressure coefficient cpc_p on the body, seen from behind, so that the slant and the base are in view. Bottom: the velocity magnitude over the inlet speed UrefU_{\mathrm{ref}} on the center plane y=0y = 0, with the body’s outline; the window is three body lengths wide. Left: the dataset’s time-averaged simulation. Right: the ISLA entry, which is the equal-weight mean of three surface networks and of eight volume networks (Section C). ISLA predicts both fields from the boundary alone. The two columns share one color scale in each row.

Slices by layer. The slices of Figure 10 change character with depth. The first two layers pool the whole car: in layer 1, three slices share every point almost equally (weights between 0.32 and 0.34), and in layer 2 one slice holds 98% of the weight. Layer 3 has 5 broad bands, and the middle layers have tens of compact patches, which begin to recur in separate places by layer 9. In the last layer the slices are many and each is scattered over the car: there a slice groups tokens by their state and no longer by their place. The mean radius of a slice’s territory (the root-mean-square distance of its points from their centroid on one side of the car, averaged over slices by area) is 0.4 m in layer 6 and 1.1 m in layer 12, compared with 1.3 m for that side of the car as a whole. No coordinate enters the routing, only invariant relations to the anchors and the learned state.

Extended Related Work

Transformers for PDEs on general geometry. Operator learning on sensors and graphs [66] (Lu et al. 2021) came before transformers. Transformers reach industrial meshes by compressing points into a small latent set: supernodes and anchor tokens [4, 5], or learned slices [60, 99, 3] (Wu et al. 2024). For slices, Wen & Mishra [92] read the slice average as a quadrature, and with Hu et al. (2026) show that Transolver does not need its attention among slices. ISLA has none. These models take coordinates as features, and their sums over points or anchors carry no measure, so their limit follows the density of the points that they are given. ISLA keeps slice routing and changes its inputs, which are invariants in place of coordinates, and its weights, which are surface measures.

Symmetry. An invariance that a model lacks must come from training examples, at a cost in data that is strict for linear models [31] and known exactly for kernel regression [85]. Two classical routes to geometric symmetry [24] constrain the layers or the inputs. The first constrains every layer through steerable or Clifford representations [86, 91, 33, 76, 35, 53, 22], and it has been applied to PDEs and flow on surfaces and in volumes [21, 84, 73]. The closest such model to ISLA in purpose is AB-GATr [73], an equivariant transformer on a subset of the points with read-only queries, which its authors train in two to eleven times the time of its non-equivariant counterpart. Even with specialized tensor-product kernels (Geiger & Smidt, 2022; cuEquivariance Contributors, 2025), carrying steerable representations through every layer adds memory and compute at industrial token counts. ISLA takes the second route: standard scalar matrix multiplications run throughout the trunk, invariant scalars go in, and invariant coefficients times covariant vectors come out at the head, following the classical representation of isotropic tensor functions [68, 98, 55, 87].

The invariants are formed relative to anchors, which have two close relatives. In Invariant Slot Attention [16], each slot of an image model has a position and a scale, and its inputs are expressed in the slot’s frame. In equivariant neural fields [93], pose-conditioned latents are related to query points through pair invariants of the kind that Bekkers et al. [15] use for message passing. ISLA relates tokens to anchors by rotation-invariant scalars, uses the mean normal as the anchor’s orientation, and forms anchors with the surface measure. No learned map receives a frame, unlike in frame averaging and learned canonicalization [71, 48]. A canonical frame cannot be both continuous and equivariant [29]; ISLA uses one only to group cells for its tree (Section B.7).

Invariants of distances and angles are not a complete set [69], so we claim no universality. Nor do we claim that built-in symmetry always helps: whether it is better than augmentation depends on the data [23, 73], and § 5.2 adds evidence from both regimes.

Units and similarity. Dimensional analysis and similarity scaling [25, 11] have been built into learning by nondimensional features [10, 88], and scale equivariance into mesh networks through the local mesh spacing [42]. GLOBES is invariant to units whenever supplies reference lengths [80]. ISLA instead computes its length unit from the boundary measure, so no reference length is an input. That unit, 2\sqrt{2} times the radius of gyration of the surface, is the size measure of statistical shape analysis.

Discretization. Neural operators are defined to converge under refinement [51], but analyses and measurements show that the property often fails [14, 34] (Sakavardia et al. 2026). DiffusionNet tests agreement between meshes of one surface [79]. For current surrogates, sensitivity to the sampling of the inputs has been observed for anchor tokens [5]. Wen & Mishra [92] find that the error of a trained Transolver has a relative standard deviation of at most 0.18% over six random subsamples drawn by one law; the tests of § 5.2 draw by another law.

ISLA makes every sum over the boundary a quadrature, an idea with several precedents. With surface measures, a weighted softmax takes the self-normalized kernel-regression form of Nadaraya [64] and Watson [90]; reading unweighted attention as a quadrature of an integral operator goes back to Cao [26]. The log-measure bias that we use is the proportional attention of token merging [17]. Yang et al. [95] apply it, with surface area as the weight, to a softmax over surface points into latent tokens, and compare it with a variant without the weight under non-uniform re-sampling. We apply the bias to the routing softmax of slice attention with one normalization per boundary condition, and draw tokens inside the forward pass as a Hájek ratio estimator with Horvitz–Thompson weights from a systematic design [61] [43, 40, 83].

From the boundary to the field. The interior form of ISLA draws on three lines of work. The first is boundary integral equations and aerodynamic panel methods: representation formulas and Steklov–Poincaré (Calderón) operators for elliptic systems and viscous flows [70, 62, 82, 52], panel and boundary-element discretizations [41, 50, 77], rigorous sample-complexity results for learning elliptic Green’s operators from their off-diagonal low-rank structure [78, 19, 20], and neural boundary-integral surrogates [54, 89]. GLOBE [80] superposes learned kernels from boundary faces, with a tree for distant faces, and ISLA’s boundary read follows it. ISLA adds learned slices for global mixing and exact distances to the boundary for near-wall resolution, which GLOBE omits by design. The second is decoding at independent query points, which is standard [46] (Lu et al. 2021). Queries that receive a state and contribute to none are used by AB-UPT [5] and SMART [39], and Transolver-3 [99] decodes full meshes from cached slice states. ISLA’s queries receive states that the boundary alone forms, and also attend to every boundary token. The third is the hierarchical summary of distant sources, from elliptic-integral treecodes, NN-body methods, H\mathcal{H}-matrices, and parallel Morton BVHs [72, 13, 37, 38, 49] to hierarchical transformers [97].

References

  1. [3]Adams, C., Ranade, R., Nidhan, S., Nabian, M. A., Akhare, D., Cherukuri, R., and Choudhry, S. GeoTransolver: Learning physics on irregular domains using multi-scale geometry aware physics attention transformer. In Advances in Neural Information Processing Systems, 2026. URL https://arxiv.org/abs/2512.20399. To appear.
  2. [4]Alkin, B., Fürst, A., Schmid, S., Gruber, L., Holzleitner, M., and Brandstetter, J. Universal physics transformers: A framework for efficiently scaling neural operators. In Advances in Neural Information Processing Systems, 2024. URL https://arxiv.org/abs/2402.12365.
  3. [5]Alkin, B., Bleeker, M., Kurle, R., Kronlachner, T., Sonnleitner, R., Dorfer, M., and Brandstetter, J. AB-UPT: Scaling neural CFD surrogates for high-fidelity automotive aerodynamics simulations via anchored-branched universal physics transformers. Transactions on Machine Learning Research, 2025. URL https://arxiv.org/abs/2502.09692.
  4. [6]Ashton, N., Angel, J. B., Ghate, A. S., Kenway, G. K. W., Wong, M. L., Kiris, C., Walle, A., Maddix, D. C., and Page, G. WindsorML: High-fidelity computational fluid dynamics dataset for automotive aerodynamics. In Advances in Neural Information Processing Systems, volume 37, pp. 37823–37835, 2024a. doi: 10.52202/079017-1194. URL https://arxiv.org/abs/2407.19320. Datasets and Benchmarks Track.
  5. [7]Ashton, N., Maddix, D. C., Gundry, S., and Shabestari, P. M. AhmedML: High-fidelity computational fluid dynamics dataset for incompressible, low-speed bluff body aerodynamics. arXiv preprint arXiv:2407.20801, 2024b. URL https://arxiv.org/abs/2407.20801.
  6. [8]Ashton, N., Mockett, C., Fuchs, M., Fliessbach, L., Hetmann, H., Knacke, T., Schonwald, N., Skaperdas, V., Fotiadis, G., Walle, A., Hupertz, B., and Maddix, D. DrivAerML: High-fidelity computational fluid dynamics dataset for road-car external aerodynamics. arXiv preprint arXiv:2408.11969, 2024c. URL https://arxiv.org/abs/2408.11969.
  7. [9]Ashton, N., Clark, A., Goc, K., Heidt, L., Ivey, C., Agrawal, R., Bose, S. T., Adams, C., Sharpe, P., Leibovici, D., Akkurt, S., Nidhan, S., Ranade, R., and Kossaifi, J. HiLiftAeroML: A high-fidelity computational fluid dynamics dataset for high-lift aircraft aerodynamics. arXiv preprint arXiv:2605.19565, 2026. URL https://arxiv.org/abs/2605.19565.
  8. [10]Bakarji, J., Callaham, J., Brunton, S. L., and Kutz, J. N. Dimensionally consistent learning with Buckingham Pi. Nature Computational Science, 2(12):834–844, 2022. doi: 10.1038/s43588-022-00355-5.DOI
  9. [11]Barenblatt, G. I. Scaling, Self-similarity, and Intermediate Asymptotics. Cambridge University Press, Cambridge, 1996. doi: 10.1017/CBO9781107050242.DOI
  10. [12]Barill, G., Dickson, N. G., Schmidt, R., Levin, D. I. W., and Jacobson, A. Fast winding numbers for soups and clouds. ACM Transactions on Graphics, 37(4):1–12, 2018. doi: 10.1145/3197517.3201337.DOI
  11. [13]Barnes, J. and Hut, P. A hierarchical O(N log N) force-calculation algorithm. Nature, 324(6096):446–449, 1986. doi: 10.1038/324446a0.DOI
  12. [14]Bartolucci, F., de Bézenac, E., Raonić, B., Molinaro, R., Mishra, S., and Alaifari, R. Representation equivalent neural operators: a framework for alias-free operator learning. In Advances in Neural Information Processing Systems, volume 36, 2023. URL https://proceedings.neurips.cc/paper_files/paper/2023/hash/dc35c593e61f6dfc6d5b411b976d09dcf-Abstract-Conference.html.proceedings.neurips.cc/paper_files/paper/2023/hash/dc35c593e61f6dfc6d5b411b976d09dcf-Abstract-Conference.html
  13. [15]Bekkers, E. J., Vadgama, S., Hesselink, R. D., van der Linden, P. A., and Romero, D. W. Fast, expressive SE(n) equivariant networks through weight-sharing in position-orientation space. In International Conference on Learning Representations, 2024. URL https://arxiv.org/abs/2310.02970.
  14. [16]Biza, O., van Steenkiste, S., Sajjadi, M. S. M., Elsayad, G. F., Mahendran, A., & Kipf, T. (2023). Invariant slot attention: Object discovery with slot-centric reference frames. In Proceedings of the 40th International Conference on Machine Learning (Vol. 202, pp. 2507–2527). https://arxiv.org/abs/2302.04973
  15. [17]Bolya, D., Fu, C.-Y., Dai, X., Zhang, P., Feichtenhofer, C., and Hoffman, J. Token merging: Your ViT but faster. In International Conference on Learning Representations, 2023. URL https://arxiv.org/abs/2210.09461.
  16. [18]Bonnet, F., Mazari, A. J., Cinnella, P., and Gallinari, P. AirFRANS: High fidelity computational fluid dynamics dataset for approximating Reynolds-averaged Navier–Stokes solutions. In Advances in Neural Information Processing Systems, 2022. URL https://arxiv.org/abs/2212.07564. Datasets and Benchmarks Track.
  17. [19]Boullé, N. and Townsend, A. Learning elliptic partial differential equations with randomized linear algebra. Foundations of Computational Mathematics, 23:709–739, 2023. doi: 10.1007/s10208-022-09556-w.DOI
  18. [20]Boullé, N., Halikias, D., and Townsend, A. Elliptic PDE learning is provably data-efficient. Proceedings of the National Academy of Sciences, 120(39):e2303904120, 2023. doi: 10.1073/pnas.2303904120.DOI
  19. [21]Brandstetter, J., Hesselink, R., van der Pol, E., Bekkers, E. J., and Welling, M. Geometric and physical quantities improve E(3) equivariant message passing. In International Conference on Learning Representations, 2022. URL https://arxiv.org/abs/2110.02905.
  20. [22]Brehmer, J., de Haan, P., Behrends, S., and Cohen, T. Geometric algebra transformer. In Advances in Neural Information Processing Systems, 2023. URL https://arxiv.org/abs/2305.18415.
  21. [23]Brehmer, J., Behrends, S., de Haan, P., and Cohen, T. Does equivariance matter at scale? Transactions on Machine Learning Research, 2025. URL https://arxiv.org/abs/2410.23179.
  22. [24]Bronstein, M. M., Bruna, J., Cohen, T., and Veličković, P. Geometric deep learning: Grids, groups, graphs, geodesics, and gauges. arXiv preprint arXiv:2104.13478, 2021. URL https://arxiv.org/abs/2104.13478.
  23. [25]Buckingham, E. On physically similar systems; illustrations of the use of dimensional equations. Physical Review, 4(4):345–376, 1914. doi: 10.1103/PhysRev.4.345.DOI
  24. [26]Cao, S. Choose a transformer: Fourier or Galerkin. In Advances in Neural Information Processing Systems, 2021. URL https://arxiv.org/abs/2105.14995.
  25. [27]Casenave, F., Roynard, X., Staber, B., Devaux-Rivière, A., Piat, W., Bucci, M. A., Akkari, N., Kabalan, A., Nguyen, X. M. V., Saverio, L., Carpintero Perez, R., Kalaydjian, A., Fouché, S., Gonon, T., Najjar, G., Daniel, T., Menier, E., Nastorg, M., Catalani, G., and Rey, C. PLAID: A unified data model for machine learning on heterogeneous physics simulations. arXiv:2505.02974, 2025. Presented at EuRIPS 2025; AI4Physics Workshop at ICML 2026.arXiv
  26. [29]Dym, N., Lawrence, H., and Siegel, J. W. Equivariant frames and the impossibility of continuous canonicalization. In Proceedings of the 41st International Conference on Machine Learning, volume 235 of Proceedings of Machine Learning Research, pp. 12228–12267, 2024. URL https://arxiv.org/abs/2402.16077.
  27. [30]Dziuk, G. and Elliott, C. M. Finite element methods for surface PDEs. Acta Numerica, 22:289–396, 2013. doi: 10.1017/S0962492913000056.DOI
  28. [31]Elesedy, B., & Zaidi, S. (2021). Provably strict generalisation benefit for equivariant models. Proceedings of the 38th International Conference on Machine Learning, 139, 2959–2969. https://arxiv.org/abs/2101.10333
  29. [32]FluidsBench. (2026). FluidsBench: Open benchmarks for scientific machine learning. https://fluidsbench.org/fluidsbench.org
  30. [33]Fuchs, F. B., Worrall, D. E., Fischer, V., and Welling, M. SE(3)-transformers: 3D roto-translation equivariant attention networks. In Advances in Neural Information Processing Systems, 2020. URL https://arxiv.org/abs/2006.10503.
  31. [34]Gao, W., Xu, R., Deng, Y., & Liu, Y. (2025). Discretization-invariance? On the discretization mismatch errors in neural operators. International Conference on Learning Representations, 19360–19384. https://proceedings.iclr.cc/paper_files/paper/2025/hash/313829757739365201b5adb3a1cbd9bd-Abstract-Conference.htmlproceedings.iclr.cc/paper_files/paper/2025/hash/313829757739365201b5adb3a1cbd9bd-Abstract-Conference.html
  32. [35]Geiger, M. and Smidt, T. e3nn: Euclidean neural networks. arXiv preprint arXiv:2207.09453, 2022. URL https://arxiv.org/abs/2207.09453.
  33. [36]Grandemange, M., Gohlke, M., and Cadot, O. Turbulent wake past a three-dimensional blunt body. Part 1. Global modes and bi-stability. Journal of Fluid Mechanics, 722:51–84, 2013. doi: 10.1017/jfm.2013.83.DOI
  34. [37]Greengard, L. and Rokhlin, V. A fast algorithm for particle simulations. Journal of Computational Physics, 73(2):325–348, 1987. doi: 10.1016/0021-9991(87)90140-9.DOI
  35. [38]Hackbusch, W. (1989). A sparse matrix arithmetic based on $\mathcal{H}$-matrices. Part I: Introduction to $\mathcal{H}$-matrices. Computing, 62(2), 89–108. https://doi.org/10.1007/s00607050015
  36. [39]Hagnberger, J. and Niepert, M. SMART: Scalable mesh-free aerodynamic simulations from raw geometries using a transformer-based surrogate model. In Proceedings of the 43rd International Conference on Machine Learning, volume 306 of Proceedings of Machine Learning Research, pp. 39376–39420, 2026. URL https://arxiv.org/abs/2601.18707.
  37. [40]Hájek, J. (1971). Comment on “An essay on the logical foundations of survey sampling, part one”. In Foundations of Statistical Inference (p. 236).
  38. [41]Hess, J. L. and Smith, A. M. O. Calculation of potential flow about arbitrary bodies. Progress in Aerospace Sciences, 8:1–138, 1967. doi: 10.1016/0376-0421(67)90003-6.DOI
  39. [42]Horie, M. and Mitsume, N. Graph neural PDE solvers with conservation and similarity-equivariance. In Proceedings of the 41st International Conference on Machine Learning, volume 235 of Proceedings of Machine Learning Research, pp. 18785–18814, 2024. URL https://arxiv.org/abs/2405.16183.
  40. [43]Horvitz, D. G. and Thompson, D. J. A generalization of sampling without replacement from a finite universe. Journal of the American Statistical Association, 47(260):663–685, 1952. doi: 10.1080/01621459.1952.10483446.DOI
  41. [45]Jacobson, A., Kavan, L., and Sorkine-Hornung, O. Robust inside-outside segmentation using generalized winding numbers. ACM Transactions on Graphics, 32(4):1–12, 2013. doi: 10.1145/2461912.2461916.DOI
  42. [46]Jaegle, A., Borgeaud, S., Alayrac, J.-B., Doersch, C., Ionescu, C., Ding, D., Koppula, S., Zoran, D., Brock, A., Shelhamer, E., Hénaff, O., Botvinick, M. M., Zisserman, A., Vinyals, O., and Carreira, J. Perceiver IO: A general architecture for structured inputs & outputs. In International Conference on Learning Representations, 2022. URL https://arxiv.org/abs/2107.14795.
  43. [47]Jordan, K., Jin, Y., Boza, V., You, J., Cesista, F., Newhouse, L., & Bernstein, J. (2024). Muon: An optimizer for hidden layers in neural networks. https://kellerjordan.github.io/posts/muon/kellerjordan.github.io/posts/muon
  44. [48]Kaba, S.-O., Mondal, A. K., Zhang, Y., Bengio, Y., and Ravanbakhsh, S. Equivariance with learned canonicalization functions. In Proceedings of the 40th International Conference on Machine Learning, volume 202 of Proceedings of Machine Learning Research, pp. 15546–15566, 2023. URL https://arxiv.org/abs/2211.06489.
  45. [49]Karras, T. (2012). Maximizing parallelism in the construction of BVHs, octrees, and k-d trees. Proceedings of the Fourth ACM SIGGRAPH / Eurographics Conference on High-Performance Graphics, 33–37. https://dl.acm.org/doi/abs/10.5555/2383795.2383801dl.acm.org/doi/abs/10.5555/2383795.2383801
  46. [50]Katz, J. and Plotkin, A. Low-Speed Aerodynamics. Cambridge University Press, Cambridge, 2 edition, 2001. doi: 10.1017/CBO9780511810329.DOI
  47. [51]Kovachki, N., Li, Z., Liu, B., Azizzadenesheli, K., Bhattacharya, K., Stuart, A., & Anandkumar, A. (2023). Neural operator: Learning maps between function spaces with applications to PDEs. Journal of Machine Learning Research, 24(89), 1 ….
  48. [52]Kress, R. Linear Integral Equations. Applied Mathematical Sciences. Springer, New York, 3 edition, 2014. doi: 10.1007/978-1-4614-9593-2.DOI
  49. [53]Liao, Y.-L. and Smidt, T. Equiformer: Equivariant graph attention transformer for 3D atomistic graphs. In International Conference on Learning Representations, 2023. URL https://arxiv.org/abs/2206.11990.
  50. [54]Lin, G., Chen, F., Hu, P., Chen, X., Chen, J., Wang, J., and Shi, Z. BI-GreenNet: Learning Green’s functions by boundary integral network. Communications in Mathematics and Statistics, 11(1):103–129, 2023. doi: 10.1007/s40304-023-00338-6.DOI
  51. [55]Ling, J., Kurzawski, A., and Templeton, J. Reynolds averaged turbulence modelling using deep neural networks with embedded invariance. Journal of Fluid Mechanics, 807:155–166, 2016. doi: 10.1017/jfm.2016.615.DOI
  52. [56]Liu, Q., Zhong, W., Meidani, H., Abueidda, D., Koric, S., and Geubelle, P. Geometry-informed neural operator transformer. arXiv preprint arXiv:2504.19452, 2025. URL https://arxiv.org/abs/2504.19452.
  53. [57]Loshchilov, I. and Hutter, F. Decoupled weight decay regularization. In International Conference on Learning Representations, 2019. URL https://arxiv.org/abs/1711.05101.
  54. [59]Cloud, L. (2025). SHIFT-SUV: High-fidelity computational fluid dynamics dataset for SUV external aerodynamics. https://huggingface.co/datasets/luminary-shift/SUVhuggingface.co/datasets/luminary-shift/SUV
  55. [60]Luo, H., Wu, H., Zhou, H., Xing, L., Di, Y., Wang, J., and Long, M. Transolver++: An accurate neural solver for PDEs on million-scale geometries. In Proceedings of the 42nd International Conference on Machine Learning, volume 267 of Proceedings of Machine Learning Research, pp. 41432–41449. PMLR, 2025. URL https://proceedings.mlr.press/v267/luo25o.html.proceedings.mlr.press/v267/luo25o.html
  56. [61]Madow, W. G. On the theory of systematic sampling, II. The Annals of Mathematical Statistics, 20(3):333–354, 1949. doi: 10.1214/aoms/1177729988.DOI
  57. [62]McLean, W. Strongly Elliptic Systems and Boundary Integral Equations. Cambridge University Press, Cambridge, 2000.
  58. [64]Nadaraya, E. A. On estimating regression. Theory of Probability and Its Applications, 9(1):141–142, 1964. doi: 10.1137/1109020.DOI
  59. [65]Olver, P. J. Applications of Lie Groups to Differential Equations, volume 107 of Graduate Texts in Mathematics. Springer, New York, 2 edition, 1993. doi: 10.1007/978-1-4612-4350-2.DOI
  60. [66]Pfaff, T., Fortunato, M., Sanchez-Gonzalez, A., and Battaglia, P. W. Learning mesh-based simulation with graph networks. In International Conference on Learning Representations, 2021. URL https://arxiv.org/abs/2010.03409.
  61. [67]Contributors, P. (2023). NVIDIA PhysicsNeMo: An open-source framework for physics-based deep learning in science and engineering. <a href="https://doi.org/https://github.com/NVIDIA/physicsnemo" rel="noopener noreferrer" target="_blank">https://doi.org/https://github.com/NVIDIA/physicsnemo</a>
  62. [68]Pope, S. B. A more general effective-viscosity hypothesis. Journal of Fluid Mechanics, 72(2):331–340, 1975. doi: 10.1017/S0022112075003382.DOI
  63. [69]Pozdnyakov, S. N., Willatt, M. J., Bartók, A. P., Ortner, C., Csányi, G., and Ceriotti, M. Incompleteness of atomic structure representations. Physical Review Letters, 125:166001, 2020. doi: 10.1103/PhysRevLett.125.166001.DOI
  64. [70]Pozrikidis, C. Boundary Integral and Singularity Methods for Linearized Viscous Flow. Cambridge University Press, Cambridge, 1992. doi: 10.1017/CBO9780511624124.DOI
  65. [71]Puny, O., Atzmon, M., Ben-Hamu, H., Misra, I., Grover, A., Smith, E. J., and Lipman, Y. Frame averaging for invariant and equivariant network design. In International Conference on Learning Representations, 2022. URL https://arxiv.org/abs/2110.03336.
  66. [72]Rokhlin, V. Rapid solution of integral equations of classical potential theory. Journal of Computational Physics, 60 (2):187–207, 1985. doi: 10.1016/0021-9991(85)90002-6.DOI
  67. [73]Rygiel, P., Suk, J., Yeung, K. K., Brune, C., and Wolterink, J. M. When does equivariance help? canonical alignment in neural fluid surrogates. arXiv preprint arXiv:2605.18816, 2026. URL https://arxiv.org/abs/2605.18816.
  68. [75]Särndal, C.-E., Swensson, B., and Wretman, J. Model Assisted Survey Sampling. Springer Series in Statistics. Springer, New York, 1992. doi: 10.1007/978-1-4612-4378-6.DOI
  69. [76]Satorras, V. G., Hoogeboom, E., and Welling, M. E(n) equivariant graph neural networks. In Proceedings of the 38th International Conference on Machine Learning, volume 139 of Proceedings of Machine Learning Research, pp. 9323–9332, 2021. URL https://arxiv.org/abs/2102.09844.
  70. [77]Sauter, S. A. and Schwab, C. Boundary Element Methods. Springer Series in Computational Mathematics. Springer, Berlin, Heidelberg, 2011. doi: 10.1007/978-3-540-68093-2.DOI
  71. [78]Schäfer, F. and Owhadi, H. Sparse recovery of elliptic solvers from matrix-vector products. SIAM Journal on Scientific Computing, 46(2):A998–A1025, 2024. doi: 10.1137/22M154226X.DOI
  72. [79]Sharp, N., Attaiki, S., Crane, K., and Ovsjanikov, M. DiffusionNet: Discretization agnostic learning on surfaces. ACM Transactions on Graphics, 41(3):1–16, 2022. doi: 10.1145/3507905.DOI
  73. [80]Sharpe, P. GLOBE: Accurate surrogates for boundary-driven PDEs via domain-inspired architectures and equivariance. In Advances in Neural Information Processing Systems, 2026. URL https://arxiv.org/abs/2511.15856. To appear.
  74. [81]Sharpe, P., Gonzales, C., Adams, C., Ataei, M., and Choudhry, S. AeroZoo: A benchmark of well-posed flow problems for foundation models of aerodynamics, 2026. arXiv preprint.arxiv.org/abs/2611.17152
  75. [82]Steinbach, O. Numerical Approximation Methods for Elliptic Boundary Value Problems. Springer, New York, 2008. doi: 10.1007/978-0-387-68805-3.DOI
  76. [83]Stevens, D. L. and Olsen, A. R. Spatially balanced sampling of natural resources. Journal of the American Statistical Association, 99(465):262–278, 2004. doi: 10.1198/016214504000000250.DOI
  77. [84]Suk, J., Imre, B., and Wolterink, J. M. LaB-GATr: geometric algebra transformers for large biomedical surface and volume meshes. In Medical Image Computing and Computer Assisted Intervention, pp. 185–195, 2024. doi: 10.1007/978-3-031-72390-2_18. URL https://arxiv.org/abs/2403.07536.
  78. [85]Tahmasebi, B. and Jegelka, S. The exact sample complexity gain from invariances for kernel regression. In Advances in Neural Information Processing Systems, 2023. URL https://arxiv.org/abs/2303.14269.
  79. [86]Thomas, N., Smidt, T., Kearnes, S., Yang, L., Li, L., Kohlhoff, K., and Riley, P. Tensor field networks: Rotation- and translation-equivariant neural networks for 3D point clouds. arXiv preprint arXiv:1802.08219, 2018. URL https://arxiv.org/abs/1802.08219.
  80. [87]Villar, S., Hogg, D. W., Storey-Fisher, K., Yao, W., & Blum-Smith, B. (2021). Scalars are universal: Equivariant machine learning, structured like classical physics. Advances in Neural Information Processing Systems, 34, 28848–28863. https://arxiv.org/abs/2106.06610
  81. [88]Villar, S., Yao, W., Hogg, D. W., Blum-Smith, B., and Dumitrascu, B. Dimensionless machine learning: Imposing exact units equivariance. Journal of Machine Learning Research, 24:1–32, 2023. URL https://arxiv.org/abs/2204.00887.
  82. [89]Wang, H., Li, J., Dwivedi, A., Hara, K., and Wu, T. BENO: Boundary-embedded neural operators for elliptic PDEs. In International Conference on Learning Representations, 2024. URL https://arxiv.org/abs/2401.09323.
  83. [90]Watson, G. S. Smooth regression analysis. Sankhya: The Indian Journal of Statistics, Series A, 26:359–372, 1964.
  84. [91]Weiler, M., Geiger, M., Welling, M., Boomsma, W., and Cohen, T. 3D steerable CNNs: Learning rotationally equivariant features in volumetric data. In Advances in Neural Information Processing Systems, 2018. URL https://arxiv.org/abs/1807.02547.
  85. [92]Wen, S. and Mishra, S. Does Transolver really need a transformer? arXiv preprint arXiv:2609.32525, 2026. URL https://arxiv.org/abs/2609.32525.
  86. [93]Wessels, D. R., Knigge, D. M., Papa, S., Valperga, R., Vadgama, S., Gavves, E., and Bekkers, E. J. Grounding continuous representations in geometry: Equivariant neural fields. In International Conference on Learning Representations, 2025. URL https://arxiv.org/abs/2406.05753.
  87. [95]Yang, Z., Du, T., and Liu, L. Learning Laplacian eigenspace with mass-aware neural operators on point clouds. In ACM SIGGRAPH 2026 Conference Papers, pp. 1–11, 2026. doi: 10.1145/3799902.3811185.DOI
  88. [96]Yoo, S., Jeong, L., Ra, J., Lee, D., Yang, S., Jeong, H., and Kang, N. DeepJEB++: Foundation model-driven large-scale 3D engineering dataset via 2D latent space augmentation. arXiv preprint arXiv:2606.12994, 2026. URL https://arxiv.org/abs/2606.12994.
  89. [97]Zhdanov, M., Welling, M., and van de Meent, J.-W. Erwin: A tree-based hierarchical transformer for large-scale physical systems. In Proceedings of the 42nd International Conference on Machine Learning, volume 267 of Proceedings of Machine Learning Research, pp. 78023–78040, 2025. URL https://arxiv.org/abs/2502.1719.
  90. [98]Zheng, Q.-S. Theory of representations for tensor functions—A unified invariant approach to constitutive equations. Applied Mechanics Reviews, 47(11):545–587, 1994. doi: 10.1115/1.3111066.DOI
  91. [99]Zhou, H., Wu, H., Shangguan, H., Ma, Y., Weng, H., Wang, J., and Long, M. Transolver-3: Scaling up transformer solvers to industrial-scale geometries. arXiv preprint arXiv:2602.04940, 2026. URL https://arxiv.org/abs/2602.04940.

Paper details

vlnc:W_ryzwyee9
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 0

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

Not recorded for this paper

View statement
Looking for related papers…
Contents