Text2PDE: Latent Diffusion Models for Accessible Physics Simulation

## Abstract

Abstract Recent advances in deep learning have inspired numerous works on data-driven solutions to partial differential equation (PDE) problems. These neural PDE solvers can often be much faster than their numerical counterparts; however, each presents its unique limitations and generally balances training cost, numerical accuracy, and ease of applicability to different problem setups. To address these limitations, we introduce several methods to apply latent diffusion models to physics simulation. Firstly, we introduce a mesh autoencoder to compress arbitrarily discretized PDE data, allowing for efficient diffusion training across various physics. Furthermore, we investigate full spatio-temporal solution generation to mitigate autoregressive error accumulation. Lastly, we investigate conditioning on initial physical quantities, as well as conditioning solely on a text prompt to introduce text2PDE generation. We show that language can be a compact, interpretable, and accurate modality for generating physics simulations, paving the way for more usable and accessible PDE solvers. Through experiments on both uniform and structured grids, we show that the proposed approach is competitive with current neural PDE solvers in both accuracy and efficiency, with promising scaling behavior up to ∼ similar-to \sim ∼ 3 billion parameters. By introducing a scalable, accurate, and usable physics simulator, we hope to bring neural PDE solvers closer to practical use.

## 1 Introduction

Neural PDE solvers are an exciting new class of physics solvers that have the potential to improve many aspects of conventional numerical solvers. Initial works have proposed various architectures to accomplish this, such as graph-based (Li & Farimani, ; Battaglia et al., ), physics-informed (Raissi et al., ), or convolutional approaches (Thuerey et al., ). Subsequent work on developing neural operators (Li et al., ; Lu et al., ; Kovachki et al., ) established them as powerful physics approximators that can quickly and accurately predict PDEs, and recent work has focused on improving many of their different aspects. These advances have established different models that can adapt to irregular grids (Brandstetter et al., ; Li et al., ; ; Wu et al., ), speed up model training (Li et al., ; Alkin et al., ; Tran et al., ; Li et al., ; ), achieve more accurate solutions (Lippe et al., ; Li et al., ), or generalize to a wide variety of parameters (McCabe et al., ; Hao et al., ; Herde et al., ; Zhou et al., ).

Figure: Figure 1: We introduce latent diffusion models for physics simulation, with the remarkable ability of generating an entire PDE rollout from a text prompt. Two generated solutions are displayed with their model inputs.
Refer to caption: extracted/5894359/figures/text_examples.png

Despite these advances, there are still many factors that limit the practical adoption of neural PDE surrogates. This is a challenging task for any emerging field: practitioners must identify novel research, train a model for their own needs, and be able to accurately deploy models beyond established benchmarks. As a field, amazing progress is being made to address this through advancing accuracy and generalizability, but this alone may not be enough. In particular, the study of neural PDE surrogates is highly interdisciplinary and fragmented. Practitioners rely on physics and numerical analysis expertise to solve PDEs, while novel research in neural solvers leverages highly specialized deep learning knowledge and practices. This makes it challenging to train and deploy neural PDE surrogates, as engineers need to learn new domain expertise to train or query novel architectures for their needs.

##### Text2PDE Models

In this work, we take a step towards addressing this by creating more accessible physics simulators that are still accurate and efficient to train, which ensures suitable performance and feasible deployment. We accomplish this by introducing language as a novel modality for interacting with physics solvers, creating text2PDE models. Language is extremely general: while different physical phenomena usually require problem-specific meshing and solvers, humans constantly observe and interact with physics and, as a result, build a common understanding and vocabulary for describing these phenomena. This lowers the barrier to entry in adopting neural surrogates: rather than needing deep learning expertise to properly query neural surrogates, practitioners can easily express ideas in language to prompt a physics model. Indeed, the popularity of text2image models is partly due to the ease of expressing visual ideas in language, rather than, for example, needing the computer vision expertise to query a class-conditional image generation model with an ImageNet label.

Beyond improving accessibility and interpretability, language can also have technical benefits. As long as the physical phenomena can be described in text, its domain specialties can be abstracted away, such as the discretization, geometries, boundaries, or physical variables. Rather than needing separate methods based on different physics expertise, text2PDE models only need to work with a single modality of language. In addition, language can be very compact; rather than needing raw physical data to specify a simulation, this information can be distilled into rich, dense textual descriptions. However, this presents unique challenges. Since text can abstractly describe a broad set of physics, the text2PDE model must generate arbitrarily discretized results. Furthermore, language can be imprecise in describing many physics problems. Lastly, producing high-dimensional spatio-temporal physics simulations from condensed text information is challenging.

##### Contributions

To address these challenges, we introduce methods to use latent diffusion models to generate PDE solutions. Within this framework, we generate an entire solution trajectory at once to avoid autoregressive error propagation and improve accuracy. Furthermore, we develop a novel autoencoder strategy to efficiently train and query models as well as to adapt latent diffusion to arbitrary discretizations. Moreover, we investigate conditioning on either text or physics modalities, such as the initial frame of a solution, to improve the precision of generated results. Lastly, we scale latent diffusion models up to nearly 3 billion parameters to show their ability to accurately generate complex outputs from compact inputs. We believe that this scalability, accuracy, and usability can unlock generative models that can bring neural PDE surrogates closer to practical adoption. To further this objective, all code, datasets, and pretrained models are released at: [https://github.com/anthonyzhou-1/ldm_pdes](https://github.com/anthonyzhou-1/ldm_pdes)

## 2 Background

### 2.1 Problem Setup

We consider modeling solutions to time-dependent PDEs in one time dimension $t=[0,T]$ and multiple spatial dimensions $\mathbf{x}=[x_{1},x_{2},\ldots,x_{D}]^{T}\in\Omega$. Following Brandstetter et al. (), we can express these PDEs in the form:

$$ $\partial_{t}\mathbf{u}=F(t,\mathbf{x},\mathbf{u},\partial_{x}\mathbf{u}, \partial_{xx}\mathbf{u},\ldots)\qquad t\in[0,T],\mathbf{x}\in\Omega$ (1) $$

Where $\mathbf{u}:[0,T]\times\Omega\rightarrow\mathbb{R}^{d_{p}}$ is a quantity that is solved for with physical dimension $d_{p}$. Furthermore, the PDE can be subject to initial conditions $\mathbf{u}^{0}(\mathbf{x})$ and boundary conditions $B[\mathbf{u}](t,\mathbf{x})=0$:

$$ $\displaystyle\mathbf{u}(0,\mathbf{x})$ $\displaystyle=\mathbf{u}^{0}(\mathbf{x})\qquad\mathbf{x}\in\Omega$ (2) $\displaystyle B[\mathbf{u}](t,\mathbf{x})$ $\displaystyle=0\qquad t\in[0,T],\mathbf{x}\in\partial\Omega$ (3) $$

##### Numerical Solvers

Conventional numerical solvers approach solving time-dependent PDEs by spatially discretizing the solution $\mathbf{u}$ at a timestep $t$ to obtain $\mathbf{u}(t,\mathbf{x_{m}})$ collocated on $M$ mesh points $\mathbf{x}_{m}\subset\Omega$ for $m\in\{0,1,\ldots,M\}$. To advance the solution in time, the spatial derivatives ($\partial_{x}\mathbf{u},\partial_{xx}\mathbf{u},\ldots$) are approximated to compute an estimate of $\partial_{t}\mathbf{u}(t,\mathbf{x}_{m})$ and used to advance the current solution in time: $\mathbf{u}(t,\mathbf{x_{m}})\rightarrow\mathbf{u}(t+\Delta t,\mathbf{x_{m}})$, also known as the method of lines (Schiesser, ). Many schemes have been developed to approximate spatial derivatives or advance solutions in time, which have varying complexities and accuracies (Butcher, ).

##### Neural Solvers

Neural solvers aim to solve time-dependent PDEs by using the solution at a current timestep to predict the solution at a future timestep $\mathbf{u}(t+\Delta t,\mathbf{x_{m}})=f_{\theta}(\mathbf{u}(t,\mathbf{x_{m}}))$. Many variants of this setup exist, whether it is to use multiple input timesteps or to predict multiple output timesteps. Despite these variants, the dominant approach still follows numerical solvers by autoregressively advancing the solution in time, with certain notable exceptions (Lienen et al., ; Du et al., ).

Autoregressive solvers are a natural choice for neural surrogates; they follow numerical solver precedents, as well as reflect the Markovian nature of time-dependent PDEs. However, this paradigm has many potential drawbacks, namely the stability of autoregressive solvers (Lippe et al., ). Although many approaches have been developed to mitigate autoregressive error accumulation (Brandstetter et al., ), the fundamental problem still exists: complex PDEs require small timescales to accurately resolve physical phenomena, yet this requires longer rollouts which increase error accumulation (Lozano-Durán & Jiménez, ; Lienen et al., ). To address this issue, we leverage spatio-temporal diffusion to directly predict an entire solution trajectory. This becomes a generative, rather than autoregressive, problem conditioned on information about the desired PDE solution.

### 2.2 Spatio-temporal Diffusion for PDEs

We consider modeling the conditional probability distribution $p$ of the discretized solution $\mathbf{u}\in\mathbb{R}^{T\times M\times d_{p}}$ at all timesteps $t\in[0,T]$ and spatial coordinates $\mathbf{x}_{m}\subset\Omega$ given the initial condition $\mathbf{u}^{0}$ and boundary condition $B[\mathbf{u}]$:

$$ $p_{\theta}(\mathbf{u}|\mathbf{u}^{0},B[\mathbf{u}])\approx p(\mathbf{u}| \mathbf{u}^{0},B[\mathbf{u}])$ (4) $$

The distribution is approximated using a denoising diffusion probabilistic model (DDPM) $p_{\theta}$ (Ho et al., ; Sohl-Dickstein et al., ). DDPMs act to reverse a noising process $q(\mathbf{x}_{n}|\mathbf{x}_{n-1})$ that transforms a PDE roll-out $\mathbf{u}=\mathbf{x}_{0}$ over $N$ steps into Gaussian noise (i.e. $q(\mathbf{x}_{N}|\mathbf{x}_{0})\approx\mathcal{N}(0,I)$). New PDE solutions can then be generated by sampling a noise vector $\mathbf{x}_{N}\sim\mathcal{N}(0,I)$ and iteratively approximating the denoising distribution $p_{\theta}(\mathbf{x}_{n-1}|\mathbf{x}_{n})$. While this generates a random sample from the distribution of all PDE samples ($\mathbf{x}_{0}\sim p(\mathbf{u})$), the trajectory of a single solution $\mathbf{u}$ is highly dependent on its initial condition $\mathbf{u}^{0}$ and boundary condition $B[\mathbf{u}]$. Therefore, the conditional denoising process $p_{\theta}(\mathbf{x}_{n-1}|\mathbf{x}_{n},\mathbf{u}^{0},B[\mathbf{u}])$ is used to model the conditional distribution in Equation 4.

Figure: Figure 2: The proposed architecture. Samples are mapped to a grid through a learned aggregation before being encoded to a latent vector and noised. A denoising process is learned, with conditioning from text or physics-based modalities. Denoised latents are decoded to a grid and mapped to a mesh through a learned interpolation.
Refer to caption: extracted/5894359/figures/overview_v2.png

##### Latent Diffusion

In the context of PDEs, this model would non-deterministically sample a full rollout $\mathbf{u}$ given its initial and boundary conditions. Since $\mathbf{u}$ can be extremely high-dimensional, we perform the forward and reverse diffusion process in a learned latent space. More specifically, given a solution $\mathbf{u}\in\mathbb{R}^{T\times M\times d_{p}}$, where $T$ represents the temporal resolution, $M$ represents the spatial resolution, and $d_{p}$ is the physical dimension, an encoder $\mathcal{E}$ can embed $\mathbf{u}$ into a latent vector $\mathbf{z}=\mathcal{E}(\mathbf{u})$. Importantly, $\mathbf{z}$ is in a compressed latent space $\mathbb{R}^{L\times d_{l}}$, where $L$ is a latent spatio-temporal resolution smaller than $T\times M$, and $d_{l}$ is the latent dimension. To project latent vectors back to the physical space, a decoder $\mathcal{D}$ is used to reconstruct a sample $\mathbf{u}=\mathcal{D}(\mathbf{z})$.

## 3 Methods

In this section, we describe the main components of using latent diffusion models for physical simulation. An overview of the methods can also be seen in Figure 2.

### 3.1 Autoencoders for PDE Data

PDE data can vary widely between equations and use cases; solutions can be discretized on a uniform or irregular mesh or contain varying physical quantities (e.g., pressure, velocity, density, etc.). In particular, practical physics applications often discretize solutions on an unstructured mesh, which aids in improving accuracy at regions of interest. This can be difficult for autoencoders to accommodate, and indeed much of the previous work is focused on compressing uniformly structured images, videos, or PDE solutions (He et al., ; Feichtenhofer et al., ; Zhou & Farimani, ).

##### Mesh Encoder

Following the problem setup, at every arbitrary timestep $t\in[0,T]$ we can consider $M$ arbitrary coordinates $\mathbf{x}_{m}\subset\Omega$ for $m\in\{0,1,\ldots,M\}$, where a solution vector $\mathbf{u}(t,\mathbf{x}_{m})\in\mathbb{R}^{d_{p}}$ is also defined. This framework captures solutions defined at any point in space and time. We map input timesteps $t$, coordinates $\mathbf{x}_{m}$, and solutions $\mathbf{u}(t,\mathbf{x}_{m})$ onto $T_{l}$ uniform timesteps $t_{l}\in[0,T_{l}]$, $M_{l}$ uniform grid coordinates $\mathbf{x}_{l}\subset\Omega$ for $l\in\{0,1,\ldots,M_{l}\}$, and latent vectors $\mathbf{q}(t_{l},\mathbf{x}_{l})\in\mathbb{R}^{d_{p}}$ at each uniform spatio-temporal coordinate. This is done with the following kernel integral:

$$ $\mathbf{q}(t_{l},\mathbf{x}_{l})=\int_{[0,T]\times\Omega}\kappa(t_{l},\mathbf{ x}_{l},t,\mathbf{x})\mathbf{u}(t,\mathbf{x})dtd\mathbf{x}$ (5) $$

In practice, following Li et al. () and Li et al. (), the domain of integration is truncated to a spatio-temporal ball with radius $r$ centered at $t_{l}$ and $\mathbf{x}_{l}$, defined as $B_{r}(t_{l},\mathbf{x}_{l})$, which enforces a constraint that latent vectors can only depend on local solutions and coordinates. Furthermore, the kernel $\kappa$ is parameterized with a network that computes a kernel value given a physical coordinate $\mathbf{y}=concat(t,\mathbf{x})$ and a latent coordinate $\mathbf{y}_{l}=concat(t_{l},\mathbf{x}_{l})$. Lastly, the integral is approximated by a Riemann sum over the $M_{b}<M$ physical coordinates that lie within the ball $B_{r}(\mathbf{y}_{l})$, denoted as $\mathbf{y}_{b}\subset[0,T]\times\Omega$ for $b\in\{0,1,\ldots,M_{b}\}$. These approximations result in the following expression:

$$ $\mathbf{q}(\mathbf{y}_{l})=\int_{B_{r}(\mathbf{y}_{l})}\kappa(\mathbf{y}_{l}, \mathbf{y})\mathbf{u}(\mathbf{y})d\mathbf{y}\approx\sum_{b}^{M_{b}}\kappa( \mathbf{y}_{l},\mathbf{y}_{b})\mathbf{u}(\mathbf{y}_{b})\mu(\mathbf{y}_{b})$ (6) $$

where $\mu(\mathbf{y}_{b})$ is the Riemann sum weight for every point $\mathbf{y}_{b}$ in the ball $B_{r}(\mathbf{y}_{l})$. To define and evaluate a latent grid, we partition the time and spatial axes into $T_{l}$ and $M_{l}$ equispaced points, resulting in $T_{l}\times M_{l}$ coordinates $\mathbf{y}_{l}$, each of which needs to have the kernel integral evaluated for it. This kernel integral essentially aggregates neighboring physical solutions for every latent coordinate.

##### Convolutional Backbone

Once a uniform latent grid $\mathbf{q}(\mathbf{y}_{l})$ is calculated, we can leverage conventional convolutional neural network (CNN) autoencoders to compress and reconstruct the data, which consists of various convolutional, upsampling, downsampling, and attention layers. Specifically, given a latent grid $\mathbf{q}\in\mathbb{R}^{T_{l}\times M_{l}\times d_{p}}$, the CNN encoder will downsample the resolution by a factor of $f$ to produce a latent vector $\mathbf{z}\in\mathbb{R}^{T_{l}/f\times M_{l}/f\times d_{l}}$, where $d_{l}$ is the latent dimension. The CNN decoder reverses this process to decode a latent grid $\mathbf{q_{d}}$ from the latent vector $\mathbf{z}$.

Using this method allows our autoencoder to benefit from architecture unification, where best practices from separate domains can benefit PDE applications. In particular, we can leverage variational or vector quantized latent spaces (Kingma & Welling, ; Esser et al., ) to avoid arbitrarily high-variance latent spaces during training. Furthermore, to improve reconstruction quality, the autoencoder can benefit from incorporating a generative adversarial network (GAN) or perceptual loss metric (Rombach et al., ; Zhang et al., ). We leave further details and ablation studies of these modifications to Appendix B.1. As a summary, we find that GANs and perceptual guidance can in certain cases improve reconstruction performance, but for simplicity, we omit them in our main results. Furthermore, we find that highly regularized latent spaces reduce downstream diffusion performance due to lower reconstruction accuracy, and that diffusion backbones are sufficiently parameterized to model higher-variance latent spaces. As a result, our main results use a small Kullback–Leibler (KL) penalty during autoencoder training.

##### Mesh Decoder

To move from the latent grid to the physical mesh, the kernel integral can be reversed. Specifically, given a decoded latent grid $\mathbf{q}_{d}(\mathbf{y}_{l})$, the decoded solution can be calculated by the Riemann sum: $\mathbf{u}_{d}(\mathbf{y})=\sum_{b}^{M_{b}}\kappa(\mathbf{y},\mathbf{y}_{b})
\mathbf{q}_{d}(\mathbf{y}_{b})\mu(\mathbf{y}_{b})$. Note that in this case, the sum is evaluated over the ball $B_{r}(\mathbf{y})$, and the coordinates $\mathbf{y}_{b}$ are defined as the latent grid points $\mathbf{y}_{l}$ that lie within $B_{r}(\mathbf{y})$. This reverse process essentially aggregates neighboring latent vectors for every physical coordinate. Lastly, for PDE problems that are uniformly discretized or resampled onto a uniform grid, the kernel integration can be omitted and a CNN autoencoder can be directly used.

##### Comparison to GNNs and Neural Fields

To demonstrate the utility of our method, we draw a comparison with previous work on processing irregular PDE data, namely using GNN or neural field approaches (Pfaff et al., ; Cao et al., ; Immordino et al., ; Yin et al., ; Serrano et al., ). Although these works do not explicitly train autoencoders, we extend these works to construct GNN- and neural field-based autoencoders to benchmark our proposed method. We provide additional details on these alternative methods as well as present auxiliary results in Appendix B.2. As a summary, we believe that the lack of inductive bias in GNNs and neural fields makes it challenging to aggressively compress and reconstruct unstructured data, which already have very little bias. The proposed approach benefits from the locality constraints of the kernel integral as well as the translation invariance, compositionality, and local connectivity of CNN kernels.

### 3.2 Latent Diffusion

Once a latent space has been learned, we consider freezing the encoder and decoder to learn the latent distribution $p(\mathbf{z})$. Specifically, we train a denoising model $\epsilon_{\theta}(\mathbf{z}_{n},n)$, where $n\in\{0,1,\ldots,N\}$ is an intermediate step within the Gaussian noising process of length $N$, and $\mathbf{z}_{n}$ is the noised latent at step $n$ (^1^11We deviate from the usual notation of $t$ representing the noising timestep to avoid overloading it with $t$ which is previously defined as physical time of the PDE solution $\mathbf{u}(t,\mathbf{x})$.). This model is trained by minimizing a reweighted variational lower bound on $p(\mathbf{z})$:

$$ $L=\mathbb{E}_{\mathbf{z},\epsilon\sim\mathcal{N}(0,\mathbf{I}),n}\left[\left \lVert\epsilon-\epsilon_{\theta}(\mathbf{z}_{n},n)\right\rVert_{2}^{2}\right]$ (7) $$

Since the latent $\mathbf{z_{0}}$ is encoded from a uniform latent grid, we can leverage a Unet to parameterize $\epsilon_{\theta}$ (Ronneberger et al., ). However, recent work by Peebles & Xie () suggests that this inductive bias is not strictly necessary, and we also evaluate the use of a diffusion transformer (DiT). Empirically, we find that the DiT backbone outperforms the Unet backbone; the main results are reported with a DiT implementation, but a full comparison can be found in Appendix C.2.

Additionally, recent advances in diffusion frameworks have proposed many modifications to the denoising process, the most straightforward of which is scaling the latent space (Rombach et al., ). Furthermore, Nichol & Dhariwal () has shown the potential benefits of using a cosine noise scheduler or learning the variance $\Sigma_{\theta}(\mathbf{z}_{n},n)$ of the reverse process. Lastly, Salimans & Ho () introduced reparameterizing the reverse process to predict the velocity $v=\sqrt{\bar{\alpha}_{n}}\epsilon-\sqrt{1-\bar{\alpha}_{n}}\mathbf{x}_{0}$, with $\bar{\alpha}_{n}$ defined as in Ho et al. (). We implement and evaluate the effects of these modifications; for interested readers, the findings can be found in Appendix C.1. In general, we find that these modifications can have a large effect on the performance of our model; however, we leave optimizing the diffusion process to future work. For our main results, we scale the latent space, use a linear noise schedule, do not learn the variance, and use an $\epsilon$ parameterization.

### 3.3 Conditioning Mechanisms

##### First Frame Conditioning

To sample from the conditional distribution $p(\mathbf{u}|\mathbf{u}^{0},B[\mathbf{u}])$, we add the conditional information to the denoising model $\epsilon_{\theta}(\mathbf{z_{n}},n,\mathbf{u}^{0},B[\mathbf{u}])$. This adds the additional consideration of how to represent initial and boundary conditions in latent space. For current PDE benchmarks and in many practical applications, the boundary conditions do not change between solutions; as such, we use $\mathbf{u}(0,\mathbf{x}_{m})$ as a proxy for both $\mathbf{u}^{0}$ and $B[\mathbf{u}]$. As such, conditioning information can be added to the denoising backbone by defining a domain-specific encoder $\tau_{\theta}$ that maps the first frame of the solution to a conditioning sequence $\mathbf{c}=\tau_{\theta}(\mathbf{u}(0,\mathbf{x}_{m}))\in\mathbb{R}^{N_{c}
\times d_{c}}$, where $N_{c}$ is the sequence length, and $d_{c}$ is the conditioning dimension. Conveniently, the proposed encoder $\mathcal{E}$ is agnostic to the temporal and spatial discretization of PDEs; therefore, the same architecture can be used for $\tau_{\theta}$ by flattening the downsampled latent dimension $(T_{l}/f\times M_{l}/f=N_{c})$.

##### Text Conditioning

Another interesting conditioning domain is natural language. Although imprecise, humans describe and understand physics through language; for example, the speed of a projectile (fast/slow), or the mass of an object (heavy/light). In principle, the initial and boundary conditions of a physics simulation could also be described by text, for example: a large plume of smoke (initial condition) entering a small box (boundary condition). An advantage of this modality is that the physical simulation can be easily prescribed; rather than needing to know the discretization scheme and the physical values at every mesh point, only the important behavior driving the physical phenomena need to be described. This has the additional benefit of removing redundancies in PDE data, as not all physical values are important, as well as improving the interpretability and usability of physics simulators. However, a clear drawback is the underdetermined nature of the PDE problem: for a given prompt describing the initial and boundary conditions, there may exist many plausible solutions. Furthermore, this approach introduces the nontrivial problem of captioning physics simulations; we develop additional methods to achieve this and interested readers are directed to Appendix D for details on PDE captioning.

Regardless, text-conditioned PDE simulators are a promising direction and to achieve this, we propose a text-specific encoder $\tau_{\theta}$ based on pretrained transformer encoders (Vaswani et al., ; Devlin et al., ). Specifically, given a tokenized and embedded prompt $\mathbf{p}\in\mathbb{R}^{N_{c}\times d_{c}}$, with sequence length $N_{c}$ and dimension $d_{c}$, a transformer encoder can produce a conditioning sequence $\tau_{\theta}(\mathbf{p})=\mathbf{c}\in\mathbb{R}^{N_{c}\times d_{c}}$. This has the additional benefit of leveraging large, pretrained transformer encoders; in particular, we fine-tune RoBERTa (Liu et al., ) to accelerate the learning of $\tau_{\theta}$.

##### Implementation

After defining two conditioning modalities and their corresponding encoders $\tau_{\theta}$, we consider mechanisms for incorporating the conditioning sequence $\mathbf{c}$ into the denoising backbones. For the Unet backbone, a cross-attention layer can be used between a flattened, hidden Unet representation $\varphi(\mathbf{z}_{n})$ and the conditioning sequence $\mathbf{c}$ (Rombach et al., ). For the DiT backbone, we apply mean pooling to produce $\bar{\textbf{c}}=mean(\textbf{c})\in\mathbb{R}^{d_{c}}$ in order to apply the adaLN-Zero conditioning proposed by Peebles & Xie (). Since mean pooling provides only global information, we also insert a cross-attention layer after self-attention DiT layers to allow hidden DiT representations $\varphi(\mathbf{z}_{n})$ to attend to the conditioning sequence $\mathbf{c}$ (Chen et al., ).

A final consideration is the use of classifier-free guidance to yield a tradeoff between sample diversity and quality (Ho & Salimans, ). For PDEs, there is only one solution for a given initial and boundary condition; as a result, the desired behavior is to enhance the sample quality at the cost of diversity. We study this effect for the conditional generation of PDE samples and report findings in Appendix D.3. We find that different weights $w$ only noticeably affect generated samples at their extrema ($w\approx 0,w>10$); as a result, classifier-free guidance is omitted from our main results.

**Table 1: Cylinder Flow. Left: Model parameters, flops, and validation losses across different benchmarks. Right: Sample rollouts for first frame and text conditioned models compared to the reference solution.**
| Model<br>Params<br>Tflops<br>L1 Loss<br>GINO<br>72M<br>0.73<br>0.0625<br>MGN<br>101M<br>32.16<br>0.0712<br>OFormer<br>131M<br>17.34<br>0.0750<br>LDMS-FF<br>198M<br>0.81<br>0.0407<br>LDMM-FF<br>667M<br>1.16<br>0.0385<br>LDMS-Text<br>313M<br>0.83<br>0.0470<br>LDMM-Text<br>804M<br>1.20<br>0.0404 |  |
| --- | --- |

## 4 Experiments

We explore the proposed latent diffusion model (LDM) for two 2D PDE datasets: flows around a cylinder (Pfaff et al., ) and buoyancy-driven smoke flows (Gupta & Brandstetter, ). Both datasets model the Navier-Stokes equations, although with different regimes, boundary conditions, solution domains, and physical variables. In particular, the cylinder flow dataset is discretized on a mesh to smoothly model the cylindrical geometry and its wake; however, the smoke buoyancy dataset is uniformly discretized in order to benchmark the proposed model against regular-grid neural surrogates, which are more common. Additional dataset details can be found in Appendix E. For each model, we report its parameter count and L1 loss. Although commonly reported, parameter count is a poor measure of training cost and model complexity (Peebles & Xie, ); therefore, we additionally report the floating point operations per second (flops) needed for a single forward pass during training with a batch size of 1, calculated using DeepSpeed (Rasley et al., ). Additional details on training and model hyperparameters can be found in Appendix F.

### 4.1 Cylinder Flow

##### Dataset

Following Pfaff et al. (), we use 1000 samples for training and 100 samples for validation. Each sample contains approximately 2000 mesh points and is downsampled to evolve over 25 timesteps, which is compressed to a latent size of $16\times 16\times 16$. Each sample is varied in the position and radius of the cylinder, as well as in the inlet velocity of the fluid. This results in samples with Reynolds numbers of around $10^{2}\sim 10^{3}$, which for this problem span the laminar and transitional regimes (Stringer et al., ). Lastly, the physical variables are velocity and pressure.

Interestingly, for this dataset, a text prompt can describe a solution well. The problem setup assumes that all parameters are fixed except for the cylinder radius, cylinder position, and inlet velocity, which can be conveniently inserted into a text prompt. In particular, to caption this dataset, we extract these values and procedurally generate prompts based on a template; for interested readers, we include further details and ablation studies in Appendix D.1.

##### Results

We consider benchmarking against GINO (Li et al., ), MeshGraphNet (MGN) (Pfaff et al., ), and OFormer (Li et al., ), which represent a variety of operator-, graph-, and attention-based neural surrogates. Since these are autoregressive models, we provide the initial frame of the solution and autoregressively predict the next 24 frames. We compare this to our latent diffusion model conditioned on both the first frame (-FF) and a text prompt (-Text), which are trained to generate a full solution trajectory at once. Furthermore, we consider two model sizes: Small (S) and Medium (M); the results are shown in Table 1.

We observe that the latent diffusion model can outperform current models on this benchmark. Notably the inclusion of flops allows for additional insight into model efficiency. We reproduce results showing that GINO models are very efficient (Li et al., ), yet LDMs can still match this efficiency by using a latent space and diffusing an entire rollout at once. Furthermore, our model is able to achieve lower errors than all baselines and more efficiently than graph- or attention-based neural surrogates. Lastly, conditioning on the first frame outperforms text conditioning, presumably because more information is provided in the initial velocity and pressure fields. However, text still remains an accurate conditioning modality; moreover, the latent diffusion model shows good scaling behavior, with increased performance at larger model sizes.

**Table 2: Buoyancy-Driven Flow. Left: Model parameters, flops, and validation losses. Text-conditioned losses^∗ are evaluated after re-solving the ground truth. Right: Sample rollout; variations in generated initial states of text models can accumulate large deviations, as such, they are evaluated against a re-solved trajectory.**
| Model<br>Params<br>Tflops<br>L1 Loss<br>FNO<br>510M<br>0.85<br>0.2134<br>Unet<br>580M<br>21.48<br>0.1287<br>Dil-Resnet<br>33.2M<br>58.75<br>0.1964<br>ACDM<br>404M<br>51.23<br>0.2063<br>LDMS-FF<br>243M<br>1.41<br>0.1540<br>LDMM-FF<br>725M<br>1.68<br>0.1386<br>LDML-FF<br>1.55B<br>2.19<br>0.1178<br>LDMS-Text<br>334M<br>1.39<br>0.1738^∗<br>LDMM-Text<br>825M<br>1.65<br>0.1320^∗<br>LDML-Text<br>2.69B<br>2.53<br>0.1240^∗ |  |
| --- | --- |

### 4.2 Buoyancy-Driven Flow

##### Dataset

We additionally evaluate our model on a regular-grid benchmark of conditional buoyancy-driven smoke rising in a square domain (Gupta & Brandstetter, ). We use 2496 training samples and 608 validation samples, with varying initial conditions and buoyancy factors, and at a spatial resolution of $128\times 128$ and 48 timesteps, which is compressed to a latent dimension of $6\times 16\times 16$. The smoke density is modeled by a passive transport equation, and as a result, the physical variables of interest are velocity in 2 dimensions and density. Since the flow is more constrained by its boundaries, this benchmark contains smaller-scale features and more complex mixing behaviors.

For the smoke buoyancy problem, it is challenging to describe an initial plume of smoke with text. In particular, plumes may exhibit different shapes, locations, and sizes, in addition to the initial velocity field being even less visually distinct. Nevertheless, we investigate captioning the initial condition using a multimodal LLM. We design a prompt and provide the density field as an image; additionally, we outline individual smoke plumes in the initial density field using a Canny edge detector (Canny, ) and provide this segmented image in the LLM prompt as well. For additional details and examples, we refer readers to Appendix D.2.

##### Results

We consider benchmarking against the popular FNO, Unet, and Dilated Resnet architectures (Li et al., ; Ronneberger et al., ; Gupta & Brandstetter, ; Stachenfeld et al., ). Additionally, we benchmark against an auto-regressive diffusion model (ACDM) (Kohl et al., ), to evaluate the need for a latent space and full spatio-temporal sample generation. To ensure a fair comparison, we only provide these baselines with the initial solution and autoregressively predict the next 47 frames. We compare this to our proposed model, conditioned on the first frame (-FF) as well as the text prompt (-Text), and in different model sizes: Small (S), Medium (M), and Large (L). The results are given in Table 2. Some higher-frequency details are lost in the LDM prediction; this could be due to working in a latent space that is 512 times smaller than the original dimension.

Due to the underdetermined nature of text conditioning, we propose an additional evaluation metric. This is motivated by the observation that text-conditioned diffusion models often generate a variety of initial conditions that semantically satisfy a given prompt, yet this can affect the temporal rollout significantly. Although the sampled solution may not match a specific solution in the validation set, it still fulfills the semantic goal of text conditioning. Therefore, use a numerical solver to evolve initial conditions taken from a sampled solution to produce the ground truth. This would evaluate the physical consistency of generated solutions without restricting the diversity of the LDM simulator. We implement this by sampling a solution for each text prompt in the validation set, then using the sampled initial condition to produce a ground-truth using PhiFlow (Holl & Thuerey, ). The results of this evaluation are also reported in Table 2, with additional results in Appendix A.

We observe that LDM models conditioned on the first frame of a PDE solution can outperform current models and are an efficient class of neural surrogates. Furthermore, text-conditioned diffusion models are able to model a set of phenomena that both semantically satisfy the prompt and are physically consistent, although the samples may not match a specific sample in the validation set. An interesting observation is that many text-conditioned samples are not contained in the training or validation sets, indicating that the generative model has learned the underlying physics to generate entirely new samples based on a text prompt. Furthermore, we note that for this specific benchmark, initial conditions are generated from a Gaussian distribution, which is inherently challenging to describe with a text prompt. Real-world problems often contain more structure that natural language can better describe, such as in the cylinder flow problem. Lastly, the LDM model displays good scaling behavior, and even at large parameter counts, its training remains efficient.

### 4.3 Discussion

Figure: Figure 3: Losses at each timestep are evaluated for 10 samples. Average losses at each timestep are bolded, individual sample losses are opaque.
Refer to caption: extracted/5894359/figures/cylinder_loss.png

We show that latent diffusion models can be a viable approach to generating spatio-temporal physics simulations. Specifically, by sampling spatio-temporal noise and leveraging the ability of diffusion models to approximate complex distributions, an entire trajectory can be generated from an initial condition. This circumvents the traditional paradigm whereby solvers need to evolve solutions based on a current timestep, and aids in increasing accuracy by preventing error accumulation. We demonstrate this by plotting the time-dependent prediction error for various models in Figure 3. Additionally, the use of a latent space allows this computation to be performed efficiently and with unstructured data. Diffusion models generally assume image-like spatially invariant data, which is usually detrimental in physics applications; the introduction of a mesh autoencoder allows latents to be denoised and decoded where solutions need to be refined (i.e. wake regions) and onto arbitrary geometries. Lastly, the scaling behavior of the proposed model is promising and reflects similar observations of scaling diffusion and attention-based models in other domains (Peebles & Xie, ; Kaplan et al., ). The benchmarked datasets are relatively small (<5000) samples; with a larger, more diverse dataset, this scaling ability could unlock unified physics surrogates across a wide variety of phenomena.

Additionally, the introduction of text-conditioned physics simulators is an interesting and novel research direction. In constrained PDE formulations, text is a compact and accurate conditioning modality, nearly matching first-frame conditioning in cylinder flow problems despite conditioning on around $1000\times$ less data (${\sim}1$Mb vs. ${\sim}1$Kb), and with the added advantage of being more interpretable and usable. In more practical scenarios where the input space is less defined, the diversity and ease of text-conditioned physics simulators could be a useful tool for engineers and designers to quickly test different ideas without needing to define geometries, discretizations, or generate an initial solution. After deciding on a suitable design, the same architecture can then be used with first-frame conditioning to more accurately model the resulting physical phenomena.

## 5 Related Works

### 5.1 Video Diffusion Models

Many prior works have considered using diffusion models to generate videos. Initial works have focused on adapting image diffusion models to the video domain, proposing many mechanisms to ensure temporal consistency or upsample spatio-temporal resolutions (Singer et al., ; Wu et al., ; Blattmann et al., ). Concurrently, many approaches have investigated directly generating videos by modifying the diffusion backbone with a 3D-Unet (Ho et al., ), with subsequent works improving the resolution, quality, and consistency of generated videos (Ho et al., ; Bar-Tal et al., ). Within these two paradigms, an abundance of research has examined the scaling of video diffusion models (Blattmann et al., ), improved conditioning methods (Girdhar et al., ), training-free adaptation (Khachatryan et al., ; Zhang et al., ), and video editing (Esser et al., ).

### 5.2 Diffusion Models for PDEs

While video diffusion models can capture an understanding of physics, PDE solutions need to be more specialized and accurate than videos. In particular, neural PDE solvers have made advances in PDE operator approximation (Kovachki et al., ), adapting to irregular meshes or boundary conditions (Li et al., ; Brandstetter et al., ), and accurately simulating complex, diverse physics (Alkin et al., ; Hao et al., ). Previous works on adapting diffusion models for PDEs have worked with generating individual timesteps and without the use of a latent space (Kohl et al., ; Lienen et al., ; Huang et al., ; Yang & Sommer, ). To improve temporal resolution and consistency, the use of a temporal interpolator has also been investigated (Cachay et al., ). Although not directly used to generate PDE solutions, diffusion has also been investigated to refine PDE solutions (Lippe et al., ; Serrano et al., ). Lastly, previous works have also considered using diffusion to accomplish alternate objectives, such as unconditional generation, upsampling PDE solutions, in-painting partial PDE solutions, or recovering solutions from sparse observations (Du et al., ; Shu et al., )

## 6 Conclusion

##### Summary

We have demonstrated that latent diffusion models represent a powerful class of physics simulators. Specifically, we have developed a framework for encoding and decoding arbitrary PDE data into a latent space to generate unstructured physics solutions. Furthermore, we have shown that generating full spatio-temporal solutions can mitigate error accumulation to improve accuracy. Lastly, we introduce conditioning on physics data as well as language, which is a novel modality that can be more compact and universal. This creation of a text2PDE model can potentially improve the accessibility and interpretability of PDE solvers. Lastly, the scaling behavior of the proposed model is promising, opening opportunities for future work in latent diffusion or text2PDE modeling.

##### Limitations

A limitation of diffusion models is the increased time and computation required for inference. For transparency, we compare the inference times of different models on the Cylinder Flow and Smoke Buoyancy problems in Appendix G. Although out of scope for this work, there exists substantial literature on accelerating sample generation, such as distillation techniques (Salimans & Ho, ; Luhman & Luhman, ; Meng et al., ), faster neural ODE solvers (Song et al., ; ; Zhang & Chen, ; Lu et al., ), and consistency models (Song et al., ), which could be a direction for future work. An additional limitation is that the LLM captioning can sometimes hallucinate, which degrades the quality of the smoke buoyancy captions and the resulting text2PDE model. Lastly, diffusing an entire rollout at once fixes the temporal resolution of the generated solution, whereas autoregressive models can generate an arbitrarily long sequence. Similar to prior video diffusion works, this can be addressed by training a separate temporal upsampler or using the proposed model in an autoregressive fashion, albeit with a large temporal window.

#### Acknowledgments

This research used resources of the National Energy Research Scientific Computing Center (NERSC), a Department of Energy Office of Science User Facility using a Generative AI for Science NERSC award DDR-ERCAP-m4732 for 2024.

## Appendix A Additional Results

Figure: Figure 4: Additional examples of text-conditioned generation of smoke buoyancy examples. The true solution is shown on top, followed by the sampled solution on the bottom. The model is only given a text description of the initial frame, which is also displayed for each example with the additional observations omitted.
Refer to caption: extracted/5894359/figures/additional_examples.png

Figure: Figure 5: Additional examples of text-conditioned generation of cylinder flow examples. The true solution is shown on top, followed by the sampled solution on the bottom. The model is only given a text description of the initial frame. The decoder still requires the mesh to properly collocate the solution.
Refer to caption: extracted/5894359/figures/cylinder_additional.png

## Appendix B Autoencoder Details

**(a) GAN/LPIPS Ablation for Cylinder Flow**
| Model | L1 Loss |
| --- | --- |
| Base | .0340 |
| +GAN | .0311 |
| +LPIPS | .0208 |

### B.1 CNN Backbone Details

We present additional results investigating the use of adversarial training and perceptual loss metrics (LPIPS) on autoencoder performance. An important consideration is that current pretrained models needed for LPIPS operate only on regularly spaced data; therefore, to maintain a fair comparison, the cylinder flow data are resampled onto a 128x32 grid to be able to evaluate an LPIPS loss. Since the benefits of using these additional methods are not clear, they are omitted from autoencoder training in the main results; however, this could be a direction for future work to improve the accuracy of LDMs. Results for the cylinder flow and smoke buoyancy problems are given in Tables 3(a) and 3(b).

##### Adversarial Training

A common technique to improve the reconstruction accuracy of an autoencoder is to introduce a discriminator to assess whether the reconstructed input is fake or real (Esser et al., ). Since our proposed mesh encoder is agnostic to the input discretization, it can also be used as a discriminator by encoding a given PDE sample, flattening the latent space, and averaging the logits. In practice, the autoencoder is trained in two stages: the first stage minimizes the reconstruction error and maximizes the probability of fooling the discriminator and the second stage optimizes the discriminator on a real and reconstructed sample.

On the cylinder flow dataset, the use of a discriminator improves autoencoder performance, however, for the smoke buoyancy dataset it does not. We hypothesize that more complex PDEs are more challenging to learn if they are fake or real, since deviations from real samples could be reasonably interpreted as eddies or high-frequency features in more turbulent regimes.

##### Perceptual Loss

Common L2 and L1 losses capture global statistics on the similarity of reconstructed and true samples, however, they can misrepresent the semantic similarity of different samples. To improve these analytical losses, Zhang et al. () propose to use differences in hidden activations of pretrained models as a loss metric. This is commonly implemented using a pretrained VGG16 model on ImageNet, however, this is hardly appropriate for PDE applications. We leverage a pretrained operator transformer from Hao et al. (), which has seen fluid dynamics data to evaluate an LPIPS loss. A final consideration is the fixed time window of pretrained PDE models; to adapt this to arbitrarily long spatio-temporal samples we autoregressively apply DPOT and average its hidden activations along a temporal rollout of the true and reconstructed samples. Again, we find that LPIPS is more beneficial for simpler physics.

**Table 4: KL Weight ($\lambda_{KL}$) Ablation for Smoke Buoyancy**
| $\lambda_{KL}$ | KL Loss | L1 Loss |
| --- | --- | --- |
| 5e-6 | 1.8e4 | 0.378 |
| 2e-7 | 4.8e4 | 0.239 |

##### KL Penalty

We evaluate the effect of different KL penalties on the variance of the autoencoder latent space as well as the prediction L1 loss after downstream training of a latent diffusion model in Table 4. We find that larger KL penalties lead to lower KL losses, indicating that the latent space is closer to a Gaussian. However, this reduces the reconstruction accuracy of the autoencoder, which degrades the performance of the latent diffusion model. Alternatively, lower KL penalties result in higher-variance latent spaces, but this is outweighed by the better reconstruction capabilities.

### B.2 GNN/Neural Field Comparisons

We consider using GNN- and neural field-based approaches to encode and decode mesh data. The results for the proposed architectures on the cylinder flow problem are given in Table 3(c). In general, the GNN and neural field methods do not seem to perform well. We hypothesize that this could because compressing large spatio-temporal samples is very challenging without proper inductive biases. Specifically, GNNs and attention-based neural field architectures are very general in their pooling and unpooling operations, which makes it challenging to extract compressed features and reconstruct dense outputs.

##### Graph Neural Networks

To compress and expand mesh-based data, we can apply graph pooling and unpooling methods. In particular, we consider a method of pooling and unpooling nodes based on bi-stride pooling (Cao et al., ). Nodes are pooled on every other BFS (Breadth-First Search) frontier in a manner that preserves connections between pooled and unpooled nodes, and doesn’t require learnable parameters. Pooled and unpooled nodes at different compression levels can be cached and used for the expansion or contraction of graphs. At the encoder, pooled nodes use message passing between unpooled nodes in a defined neighborhood to aggregate information and downsample the graph. At the lowest resolution, we apply cross-attention between the node list and a fixed latent vector, similar to Perceiver pooling (Jaegle et al., ). To interpolate a fixed latent back onto a graph, a we use cross-attention between a fixed latent and a learnable latent node list, which is truncated to the correct dimension. The low-resolution graph can be used as supernodes in a cached upsampled graph to pass messages to their unpooled neighbors until the original graph is reconstructed.

##### Neural Fields

Neural fields represent a mapping between a set of coordinates and their functional values. While this is restricted to modeling a single sample, the addition of a condition in conditional neural fields allows this framework to be adapted to different PDE samples. To compress an arbitrary spatio-temporal vector, the spatial and temporal axes are separately aggregated using Perceiver pooling. Specifically, the architecture alternates between computing the cross-attention on spatial or temporal points and a fixed vector. This can then be downsampled or upsampled using conventional CNN methods. To interpolate a fixed latent back onto an output mesh, the fixed latent can be seen as a condition for a neural field queried at the output mesh. We implement this based on the CViT architecture (Wang et al., ). A transformer encoder computes self-attention to encode the latent vector into a condition, while the query coordinates are interpolated from a learned latent grid. A transformer decoder then calculates the cross-attention between the query points and the condition, which is decoded to the reconstruction.

## Appendix C Diffusion Details

### C.1 Denoising Ablations

**(a) Parameterization**
| Model | $L_{simple}$ |
| --- | --- |
| Noise | 0.056 |
| Velocity | 0.072 |

##### Denoising Parameterization

We investigate parameterizing the reverse process by predicting the velocity $v=\sqrt{\bar{\alpha}_{n}}\epsilon-\sqrt{1-\bar{\alpha}_{n}}\mathbf{x}_{0}$, rather than the noise $\epsilon$ (Salimans & Ho, ). This is motivated by the idea that the prediction of pure noise becomes increasingly unstable as the number of timesteps decreases. We find that v-prediction slightly increases the VLB loss, however, this effect is not significant.

##### Learning Σ θ subscript Σ 𝜃 \Sigma_{\theta} roman_Σ start_POSTSUBSCRIPT italic_θ end_POSTSUBSCRIPT

Following Nichol & Dhariwal () we parameterize the reverse process variance as $\Sigma_{\theta}(z_{t},t)=\exp(v\log\beta_{t}+(1-v)\log\tilde{\beta}_{t})$, where $v$ is a learned vector that modulates the transition between $\beta_{t}$ and $\tilde{\beta}_{t}$. Furthermore, the loss is modified to minimize the log-likelihood. We find that learning $\Sigma_{\theta}$ does not significantly effect the reverse process.

##### Latent Space Scaling

Following Rombach et al. (), we scale the latent space to approximate unit variance across latent encodings of the training set. When the latents are too large, the addition of Gaussian noise with unit variance does not sufficiently noise the latents ($z_{T}\neq\mathcal{N}(0,I)$), which harms the denoising process during inference. While the KL-loss could be increased during autoencoder training to limit the variance of the learned latent space, this comes at the cost of reduced reconstruction accuracy. As such, scaling the latent space is an important consideration, and a proper scaling factor is needed to achieve good results.

##### Noise Scheduler

Following Nichol & Dhariwal (), we evaluate using a cosine or linear noise scheduler. We find that empirically, a linear noise scheduler performs better in our case; however, optimizing the noise schedule is still an area for future work.

**Table 6: Different model architectures for the Cylinder Flow problem**
| Model | Val L1 Loss |
| --- | --- |
| Unet-FF | 0.0416 |
| Unet-Text | 0.0492 |
| DiT-FF | 0.0385 |
| DiT-Text | 0.0404 |

### C.2 Diffusion Backbone Architectures

We evaluate parameterizing the reverse process using a 3D Unet or DiT in Table 6. In both cases, the models need to predict spatio-temporal noise, either by using 3D convolutions or patchifying across space and time. Models are trained with approximately the same parameter count and conditioning on either the first frame or a text prompt for the cylinder flow problem. We report L1 losses between generated samples and the validation set. We find that a DiT backbone slightly outperforms a Unet backbone.

## Appendix D Conditioning Details

### D.1 Cylinder Flow Captioning

For the cylinder flow problem, we extract the cylinder radius, position, inlet velocity, and Reynolds number from the first frame. Additionally, we determine the flow regime based on the Reynolds number: Re<200 = laminar, Re<350 = transition, Re>350 = turbulent. Additionally, since the cylinder radius is much smaller than the domain, its dimensions are given in centimeters, while the position is given in meters. These values are inserted into the prompt below:

"Fluid passes over a cylinder with a radius of {cylinder_radius:.2f}
and position: {cylinder_pos[0]:.2f}, {cylinder_pos[1]:.2f}.
Fluid enters with a velocity of {inlet_velocity:.2f}.
The Reynolds number is {reynolds_number}. The flow is {flow_regime}."

**Table 7: Different model architectures for the Cylinder Flow problem**
| Model | Val L1 Loss |
| --- | --- |
| Full Prompt | 0.0404 |
| Text-Ablate | 0.2168 |
| Vector-Ablate | 0.1029 |

Since the text prompt is procedurally generated, we ablate the full prompt against two baselines. The first baseline considers generating a text prompt solely with the extracted values, without any of the context or surrounding text, and uses the same RoBERTa model to encode the condition (Text-Ablate). The second baseline embeds the extracted values, normalized between -1 and 1, into a vector and uses an MLP to encode the condition (Vector-Ablate). We train these two baselines as well as a model using the full prompt and evaluate the L1 loss on the validation set in Table 7. We find that the extra context is beneficial for language models in understanding the meaning of different extracted values. Furthermore, using a language model can be a more expressive way of encoding low-dimensional physical values into a meaningful condition.

### D.2 Smoke Buoyancy Captioning

The captioning procedure for the smoke buoyancy dataset is more challenging, since the initial density and velocity fields do not contain features that are easily extracted and described by text. To address this, we prompt an LLM (Claude 3.5 Sonnet) to process an image of the initial density field and describe its trends. Furthermore, to improve the quality of generated captions, we use a Canny edge detector to outline shapes in the original image and provide this segmented image in the LLM prompt as well. The full prompt is given below.

You will be analyzing an image of a simulation of the Navier-Stokes equations to identify smoke plumes,
count them, and describe their characteristics. You will also be provided an image with the boundaries of
the smoke plumes drawn over the simulation in green.
Follow these instructions carefully:
First, examine the provided image:
<image>
Second, examine the provided segmented image:
<segmented_image>
To identify plumes:
1. Look for regions of bright color, which contrast against the darker background.
2. Pay attention to color variations and changes in the shape of the plumes.
3. Use the green lines in the segmented image to help identify the boundaries of the plumes.
To count the number of plumes:
1. Scan the entire image systematically.
2. Use the green lines in the segmented image to help separate different plumes.
3. Pay attention to darker regions that separate different plumes.
To describe each plume’s shape, size, and location:
1. Shape: Characterize the overall form (e.g., column-like, mushroom-shaped, dispersed cloud,
triangular, curved) and changes in shape of the plume.
2. Size: Estimate the relative size compared to other elements in the image (e.g., small, medium, large)
and describe how the plume changes in size.
3. Location: Describe the position using general terms (e.g., upper left corner, center, lower right)
or in relation to other smoke plumes.
Remember to use the segmented image to help describe each plume’s shape, size, and location.
Present your findings in the following format:
<answer>
Number of plumes identified: [Insert number]
Plume descriptions:
1. [Shape], [Size], [Location]
2. [Shape], [Size], [Location]
(Continue for each plume identified)
Additional observations: [Only include any relevant details about the overall patterns or shapes observed.
Pay attention to symmetry and how the plumes interact with each other.]
<answer>
Remember to be as descriptive and accurate as possible in your analysis.

We find that using a segmented image improves quantitative and qualitative metrics in labeling physics simulations. In particular, the correct number of smoke plumes are identified more often, and the resulting descriptions are richer and more detailed. We give an example in Figure 6. Additionally, to inform models of the forcing term, the buoyancy factor is prepended to the LLM answer by inserting it into the template: ”The buoyancy factor is $\{\}$.”. We also compare the responses of Claude 3.5 Sonnet, Gemini 1.5 Pro, and GPT-4o in Figure 6.

Figure: Figure 6: Comparison of LLM outputs after prompting with the original image, or both the original and a segmented image. We also compare responses from Claude 3.5 Sonnet, Gemini 1.5 Pro, and GPT-4o.
Refer to caption: extracted/5894359/figures/prompt_example.png

### D.3 Classifier-Free Guidance

Classifier-free guidance can be a method to modulate the strength of the conditioning information. This is implemented by using conditional dropout during training and combining conditional and unconditional noise estimates during inference:

$$ $\tilde{\epsilon}_{\theta}(\mathbf{z}_{n},n,\mathbf{c})=(1+w)\epsilon_{\theta}( \mathbf{z}_{n},n,\mathbf{c})-w\epsilon_{\theta}(\mathbf{z}_{n},n)$ (8) $$

The weight $w$ modulates the tradeoff between sample quality and diversity, with larger values increasing the guidance strength and decreasing sample diversity. Following Lin et al. (), we also rescale the conditional portion of the sample generation process with the recommended value of $\phi=0.7$. Empirically, we find that only at very large or small weights does the generated sample change appreciably. We plot the trends in Figure 7 for first-frame conditioning. We find that at large values of $w$, much of the generated solution is saturated and many features are washed out. At low values of $w$, many features are not present and the generated solution displays a lack of phenomena. We hypothesize that classifier-free guidance is not necessary for physics applications where the primary concern is the numerical accuracy of solutions, rather than diversity or visual quality. Indeed, the validation L1 loss of models trained without classifier-free guidance ($w=1$) is often better than using other values of $w$. The original VLB objective seeks to push generated samples closer to the training distribution; we hypothesize that modifying the inference with alternate sampling approaches deviates from this objective and produces less accurate results.

Figure: Figure 7: Comparison of different weights used for classifier-free guidance. In general, using vanilla conditional generation results in the most accurate solutions.
Refer to caption: extracted/5894359/figures/cfg.png

## Appendix E Dataset Details

### E.1 Cylinder Flow

We use data from Pfaff et al. (), which is generated from water flowing over a cylinder constrained in a channel, modeled by the incompressible Navier-Stokes equations:

$$ $\frac{\partial\mathbf{v}}{\partial t}+\mathbf{v}\cdot\nabla\mathbf{v}=\nu \nabla^{2}\mathbf{v}-\frac{1}{\rho}\nabla p+\mathbf{f},\qquad\nabla\cdot \mathbf{v}=0$ (9) $$

The original data are generated using COMSOL, with 600 timesteps from $t=0$ to $t=6$ on a spatial domain $(x=[0,1.6],y=[0,0.4])$, with varying inlet velocities and cylinder sizes/positions. To speed up our experiments, we downsample along the temporal dimension to 25 timesteps. We use 1000 samples for training and 100 samples for validation.

### E.2 Smoke Buoyancy

We use data from Gupta & Brandstetter (), which is generated from smoke driven by a buoyant force constrained in a box, modeled by the incompressible Navier-Stokes equations coupled with an advection equation representing the smoke density $d$:

$$ $\displaystyle\frac{\partial\mathbf{v}}{\partial t}+\mathbf{v}\cdot\nabla \mathbf{v}=\nu\nabla^{2}\mathbf{v}-\frac{1}{\rho}\nabla p+\mathbf{f},\qquad \nabla\cdot\mathbf{v}=0$ (10) $\displaystyle\frac{\partial d}{\partial t}+\mathbf{v}\cdot\nabla d=0$ (11) $$

The original data are generated using PhiFlow (Holl & Thuerey, ), with 56 timesteps from $t=18$ to $t=102$, which results in $\Delta t=1.5s$. Furthermore, the simulation is solved on a spatial domain $(x=[0,32],y=[0,32])$ with a resolution of $128\times 128$. To ensure compatibility with downsampling operations, which occur with a factor of 2, we truncate the simulation horizon to $t=48$. We use 2496 samples for training and 608 samples for validation.

## Appendix F Training Details

To maintain a consistent setup in all experiments, the only ground truth information provided to each model is from the first frame of the simulation. Additionally, to maintain a fair FLOPs comparison, the compute required for autoregressive models during training is multiplied by the number of timesteps. This is because the LDM model considers all timesteps at once during training, while autoregressive models only consider a single timestep.

### F.1 Cylinder Flow

All baselines were trained on a single NVIDIA RTX 6000 Ada GPU with a learning rate of $10^{-5}$ until convergence. LDM models were trained on a single NVIDIA A100 40GB GPU. For each model, we describe the key hyperparameters.

##### GINO

We train a GINO model with a latent grid size of 64 and GNO radius of 0.05. Furthermore, the FNO backbone uses a hidden dimension of 128 and 32 modes.

##### MeshGraphNet

We train a MGN model with 8 layers and a hidden size of 1024.

##### OFormer

We train an OFormer model with 6 layers and a hidden size of 512.

##### LDM

We train an autoencoder with a latent grid size of 64, GNO radius of 0.0425, hidden dimension of 64, and 3 downsampling layers, resulting in a latent size of $16\times 16\times 16$, which is a compression ratio of around 48. Additionally, the DiT backbone uses 1000 denoising steps, a patch size of 2, a hidden size of (512/1024), and a depth of (24/28) depending on model size.

### F.2 Smoke Buoyancy

All baselines were trained on a single NVIDIA RTX 6000 Ada GPU with a learning rate of $10^{-4}$ until convergence. LDM models were trained on four NVIDIA A100 40GB GPUs. For large models, four NVIDIA A100 80GB GPUs were used to handle memory requirements. For each model, we describe the key hyperparameters.

##### FNO

We train a FNO model with a hidden dimension of 192, 24 modes, and 6 layers.

##### Unet

We train a Unet model with 4 downsampling layers and a hidden size of 128, with architecture modifications (Unetmod) proposed in Gupta & Brandstetter ().

##### Dil-Resnet

We train a Resnet with a hidden dimension of 256, 4 layers, and a dilation of up to 8.

##### ACDM

We train an ACDM model with a single conditioning frame and with a Unet backbone with a hidden dimension of 256 and 4 downsampling layers.

##### LDM

We train an autoencoder with a hidden dimension of 64 and 4 downsampling layers, resulting in a latent size of $6\times 16\times 16$, which is a compression ratio of 512. Additionally, the DiT backbone uses 1000 denoising steps, a spatial patch size of 2 and a temporal patch size of 1, a hidden size of (512/1024/1536/2304) and a depth of (24/28) depending on model size.

## Appendix G Inference Time Comparison

**(a) Inference Time for Cylinder Flow**
| Model | Params | Inference Time (s) |
| --- | --- | --- |
| GINO | 72M | 0.112 |
| GNN | 101M | 1.683 |
| OFormer | 131M | 1.336 |
| LDMS-FF | 198M | 15.753 |
| LDMM-FF | 667M | 27.895 |
| LDMS-Text | 313M | 16.251 |
| LDMM-Text | 804M | 29.096 |

For transparency, we report inference times of all models on both the Cylinder Flow and Smoke Buoyancy benchmarks in Table 8. We reproduce previous results that GINO is an efficient architecture for unstructured problems (Li et al., ). Furthermore, we reproduce previous results demonstrating the increased compute needed for dilated Resnets (Li et al., ). Lastly, we find that our latent diffusion framework is much faster than prior work on autoregressive diffusion or learning directly in the pixel space.

However, we recognize that the increased latent diffusion inference times may be a potential limitation. The current implementation uses 1000 denoising steps, which leaves ample room for accelerating inference. Indeed, the latent diffusion is on the order of 10 times slower than deterministic methods. This is a margin that using 10 times fewer denoising steps (100 steps) may be able to address, and without significant loss of accuracy if using modern techniques such as distillation. Furthermore, diffusion sampling may still be faster than using numerical counterparts.

This is a challenging claim to quantify, as the numerical solver needs to be coarsened to match the accuracy of the neural solver, as well as a reasonable effort needs to be made to compare against a state of the art numerical solver (McGreivy & Hakim, ). The solvers used for the Cylinder Flow and Smoke Buoyancy benchmarks are COMSOL and PhiFlow, which are both high-performance numerical packages. Unfortunately, we do not have access to the COMSOL code to solve the cylinder flow problem with reduced accuracy. However, the original authors report a speedup of 11-290x (Pfaff et al., ), which may be enough margin to overcome coarsening the simulation to 90% of its original accuracy (see Table 1, .04 L1 Loss corresponds to about 10% normalized L1 error for this dataset).

However, for the smoke buoyancy benchmark, we have access to PhiFlow and, in fact, use it to re-solve text-conditioned samples. We compare the accuracy and speed of using PhiFlow at lower resolutions with latent diffusion models in Table 9. PhiFlow was solved faster on our CPU (AMD Ryzen Threadripper PRO 5975WX 32-Cores) than on our GPU (NVIDIA RTX 6000 Ada), so numerical solver times are reported using the CPU. When running lower-resolution PhiFlow simulations, the original initial condition was downsampled, evolved with the solver, and upsampled using bicubic interpolation. There are tangible accuracy and speed gains from using a latent diffusion model; however, faster inference techniques will likely be needed to vastly outperform numerical solvers. Also of note is that text2PDE generation is something that numerical solvers cannot do.

**Table 9: Comparison of inference speed and accuracy. PhiFlow-X denotes the spatial resolution used for numerical simulation. PhiFlow speed and accuracy values are averaged over five validation samples.**
| Model | Inference Time (s) | Val L1 Loss |
| --- | --- | --- |
| LDMS-FF | 16.863 | 0.154 |
| LDMM-FF | 25.233 | 0.139 |
| LDML-FF | 57.442 | 0.118 |
| LDMS-Text | 16.294 | 0.174 |
| LDMM-Text | 26.494 | 0.132 |
| PhiFlow-32 | 69.266 | 0.172 |
| PhiFlow-64 | 70.569 | 0.116 |
| PhiFlow-128 | 75.468 | 0 (Ground-Truth) |

## Peer Reviews

confidence: 3
contribution: 2
initial_rating: 5
presentation: 2
questions: - what is re-solved trajectory referred to in line 394?
- why doing text-conditioned simulation generation, is the pde type pre-defined for each model? How important is the training data text caption?
- how does text-conditioning help the simulation results or they are dis-entangled.
soundness: 2
strengths: - apply latent diffusion models to physics simulation with mesh encoder/decoder provide a scalable solution. 
- a new text conditioned PDE simulation framework. 
- supporting both structured and unstructured grids, and shows promising results on different types of PDE problems
summary: this paper introduce framework for text to simulation use latent diffusion models, enables condition on language, initial conditions. this work generate a entire trajectories for improved accuracy without error accumulation.
weaknesses: -  it's unclear the benefits and why doing text-conditioned simulation generation
- I find paper's contribution is more on using latent diffusion for pde simulation, not the text to PDE generation.

---

confidence: 3
contribution: 2
initial_rating: 5
presentation: 3
questions: 1. As the text prompts appear to accurately capture the first frame of the reference (as shown in Table 2 and Figure 4 in Appendix A), I wonder if the model is memorizing and retrieving the smoke plume from the training dataset that most closely matches the input. For the existing prompts, would it be possible to display the most similar first frame from the training set?
soundness: 1
strengths: 1. Thanks to the encoding of arbitrary meshes, the authors are able to apply their method to complex geometries – an important use case for the application of PDEs.
1. The main strength of the paper is the introduction of text conditioning for generation of PDE trajectories. The idea is novel and opens up a new research direction.
However, it would be still interesting to see more specific motivating examples of where text conditioning could be useful in real-world use cases of PDE solvers.
summary: The paper introduces a framework called TEXT2PDE, which employs text-conditioned latent diffusion models (LDMs) to model spatio-temporal PDE trajectories. The authors introduce a mesh autoencoder that can encode and decode physical fields on arbitrary meshes. Spatio-temporal trajectories are generated using a conditional denoising process of an LDM with the initial conditions and boundary conditions of the PDE imposed into the conditioning sequence of the denoising backbone. A main novelty is the introduction of text conditioning, by employing a pre-trained transformer encoder. The authors argue that using natural language as a conditioning modality can improve the interpretability and usability of neural PDE solvers.
weaknesses: 1. The evaluations seem lacking when assessing the text conditioning capability of the Text2PDE model. Firstly, the initial and boundary conditions of the cylinder dataset can be entirely encoded using just three real numbers, making the expressiveness of natural language excessive for this case. Secondly, the smoke dataset appears to be a poor fit for text-based description, as the smoke plumes are too unconstrained and unstructured to be accurately captured by language. (See also the question 1.)

2. In my opinion, evaluating text conditioning would require a new dataset with more regular shapes placed in general positions. The configurations should be rich enough to necessitate natural language for description, but constrained enough that a short text can accurately describe the image. Currently, it seems that the TEXT2PDE system is limited to using text conditioning to generate only the initial condition. This could be achieved more directly by combining text-to-image techniques and then running a standard (neural) PDE solver. The added benefit of using a combined system is not clear. It could be more interesting (and useful) if the PDE dynamics were also informed by natural language—perhaps through a text-encoded equation.

---

confidence: 5
contribution: 2
initial_rating: 5
presentation: 3
questions: - Autoregressive vs entire solutions. It is not clear whether producing an entire solution trajectory is really beneficial. First of all it doesn’t scale to 3D problems or larger 2D problems. Secondly, it might be unphysical. Do the authors have insights on this?
soundness: 3
strengths: - Latent space modeling for physics simulations. By using latent diffusion models, the authors effectively compress and encode high-dimensional physics data into a lower-dimensional latent space. Such latent space approaches contribute to more adaptable and faster simulations, making it a powerful alternative to traditional numerical solvers. There is a surge of latent space PDE models, this paper fits well into this paradigm. The full spatio-temporal diffusion modeling conditioned on text prompts and the subsequent decoding stands out as unique modeling approach.

- Text prompts for simulation control. Text2pde is an interesting direction since it allows users to define simulation parameters or initial conditions using simple, interpretable text commands. The potential for language-based input makes physics simulations more accessible and generalizable. Yet it is not clear what is the difference to simple parameter modulation, the nice capturing of the initial condition is cool.

- Application to mesh-based dynamics.
summary: The authors introduce a new approach to physics simulations using latent diffusion models. Their method is anchored by (i) the use of mesh autoencoders, (ii) full spatio-temporal modeling to avoid autoregressive error accumulation, and (iii) conditioning on text prompts.
weaknesses: - Text2pde seems to be hard to scale to larger problems. To avoid confusion: scalability here refers to input representations. The mesh autoencoder is a good direction, yet the latent space is a latent grid, which if going to 3D is fundamentally limiting. Also for larger 2D grids, a tokenized representation might be preferable. Secondly, the generation of the full trajectory is storage intensive, and for 3D problems would result in a 4D tensor, which is computationally infeasible. Most turbulent problems, where neural surrogates might shine are 3D, presenting a drawback of the applicability of the method.
- Text conditioning in this framework seems to be a slightly sophisticated parameter conditioning / parameter modulation. The nice feature so far is the generation of the initial mesh, initial condition. It would greatly help to make these differences clearer. Further the text prompt part needs to be adapted for each problem individually. It should be clarified how the text part can maybe be used across settings? Is this even possible?

---

confidence: 5
contribution: 3
initial_rating: 6
presentation: 3
questions: The author should write down more about when, who will need this method to do what. And the flow past cylinder data seems under-resolved. The mesh is too coarse, can we make it finer?
soundness: 3
strengths: It is first time people to get-like fluid sequence generation, to combine llm with diffusion is good.
summary: Very new paper. I support this because it actually works, I appreciate the authors working! Just like language model for catalyst. But I just do not see why people need this as they need for catalyst-gpt. The authors know fluid, they do not need this even they can make this fluid-gpt. For people do not know fluid, why they need it?
weaknesses: The motivation is lacking. The flow simulation is not physical.

---

confidence: 3
contribution: 2
initial_rating: 5
presentation: 3
questions: The example of Cylinder Flow describes that the physical variables are velocity and pressure. Do the reported L1 Loss values take into account both variables? If so, the errors of both variables should be discussed more thoroughly.

Similarly, it would be worth having further clarification of the error for two variables (velocity and density) in the Buoyancy-driven Flow example.

In Buoyancy-driven Flow, the samples vary with not only initial conditions but also buoyancy factors. Does the model get conditioned with the buoyancy factor? I guess not. Then, the trajectories (evolved with different buoyancy factors) represent somewhat different physics. In this case, I am not sure how the model has learned the underlying physics.

It would be valuable to see how the radius of a spatio-temporal ball affects the model performance.

It would be helpful to clarify how to define/train the kernel $\kappa(\cdot)$.
soundness: 3
strengths: Under the aim of developing a surrogate neural PDE solver, the paper claims three major novelties (also with their strengths) of the proposed model.

1. En/decoding PDE data via a uniform spatiotemporal latent grid: Regardless of discretization, the PDE data is first encoded into the uniform grid via a weighted sum using a learned parameterized kernel. Its architecture unification is beneficial, and thanks to the benefit, the conventional CNN can outperform GNN and Neural Fields in training an autoencoder for irregular data.

2. Latent diffusion model for entire solution trajectory prediction: Instead of a state prediction of the autoregressive model, the proposed neural PDE solver aims to predict the trajectory given initial and boundary conditions. This generative model can mitigate error accumulation, and the work compares with other models.

3. Text conditioning: In addition to the traditional physics-state initial and boundary conditions, the paper proposes to use natural language as a means of conditioning. The authors claim that this can be a promising direction for PDE simulators.

Overall, with the combination of these novelties, the paper claims their surrogate PDE solver outperforms the other models such as GINO, OFormer, FNO, ACDM, etc.

Additionally, thanks to the accompanying codes, the results should be reproducible (although I did not run the codes myself).

---

***During the discussion,*** the authors clarified my concerns; thus I raised my score to 6 from 5.
summary: This paper proposes a surrogate neural network model that solves PDE problems. The authors claim innovations in three parts: mesh en/decoder, latent physics solver, and conditioning. The mesh en/decoder unifies differently discretized solution data achieved from various numerical solvers. Unlike an autoregressive model, the latent physics solver utilizes a diffusion model and predicts a full spatiotemporal solution. For the conditioning, two mechanisms, i.e., state-based and text-based methods, are proposed.
weaknesses: As the title "text2pde" stands for, the paper proposes a text-based conditioning for PDE. Although it is an interesting direction to investigate, the practical benefit of the current model is not fully convincing to me. If I am not wrong, the text-based conditioning of the proposed method eventually relies on a set of extracted values that are necessary to set up the initial condition, and this is only for conditioning a single initial frame. In my view, this can be easily and more precisely defined with a script-based (or template-based) initialization. Arguably, the text-based approach may rather be an ambiguous means to use in this context. Moreover, this part looks independent of the solver; it tackles how to generate an image (i.e., a PDE state in this context) from a text, which looks closer to text2image rather than text2pde.

The validation of the proposed solver could be further improved. Only two examples of N.-S. equations were investigated. The proposed entire-trajectory prediction was only evaluated for 25 steps in the cylinder flow case with low turbulence, which is relatively less complex, and 48 steps in the buoyancy-driven flow. Further experiments for the multi-step trajectory prediction would improve the validation.

---

confidence: 5
contribution: 2
initial_rating: 3
presentation: 2
questions: 1. The reviewer has some doubts about the selected generative model. For such prediction and simulation tasks, diffusion models are not always effective due to their SDE features. Flow matching, which is based on ODEs, appears more suitable for PDE solvers. Could the authors discuss the application of both models for PDE solvers and explain why they chose diffusion models over flow matching?
2. In line 229, "we find that GANs and perceptual guidance can in certain cases improve reconstruction performance, but for simplicity, we omit them in our main results." The author said GANs can improve the performance, but why you do not apply GANs?
3. In Figure 5, the middle two figures do not show turbulent flow, making this characterization inaccurate. Specifically, the second figure clearly shows laminar wake flow, and while the third figure shows vortices, it has not yet reached turbulent conditions.
soundness: 3
strengths: 1. The developed framework encodes and decodes arbitrary PDE data into a latent space to generate unstructured physics solutions.
2. The language model is applied in the framework to make the PDE solver more accessible.
3. The paper applies two experiments to demonstrate the superior performance of the proposed method.
summary: This work presents a more accessible physics simulation by introducing the language model so that the physics solver can be interacted by using the test, called text2PDE. The proposed method is verified cylinder flow and buoyancy-driven flow although they cannot demonstrate enough the claimed effect.
weaknesses: 1. The reviewer raises doubts about the novelty and contribution of the work, seemingly only using the encoding of the language model as a condition to generate solutions of PDEs.
2. Why do the two experiments adopt different baselines and lack baselines such as FNO for cylinder flow?
3. From line 047 to 050, while this statement may seem obvious, it's not a scientific issue. It is necessary to have physics and numerical knowledge to build PDE solvers. At the same time, approaches based on FNO, DeepOnet and similar numerically-driven methods can learn accurate PDE solvers without requiring physics knowledge.
4. From line 053, this work deviates from the challenges described above, and there are concerns about potential overclaiming. Based on the author's two experiments, the proposed model only works in specific PDEs, spatiotemporal dimensions, and simple scenarios where the required physics knowledge is quite basic. In other words, the authors failed to address a crucial question: for complex PDE systems, how to represent the system using language, when mathematical formulas are clearly more suitable, while it is the main challenge the reviewer understand from the previous paragraph.
5. Spatial and temporal resolution is crucial for PDE solvers. How does this work handle different spatial resolutions? Specifically, how does this method distinguish between initial conditions with different resolutions within the same system?
6. Could you provide more details about the autoencoder in Sec. 3.1? This part is quite abstract and difficult for readers to understand intuitively. Please briefly explain the autoencoder's architecture, input/output structure, and training methodology. Additionally, during the diffusion model training, is the encoder trained simultaneously or are its parameters fixed?
7. In line 235, the decoder appears to be CNN-based, which imposes constraints on the spatial dimensions of the output solutions. Furthermore, interpolation operations can lead to inaccuracies in the results, even when solutions on regular grids are accurate.
8. In the method section, the authors have placed too many crucial details in the appendix, like Appendix C.2, B.1, B.2, D, making it impossible to understand the method without referring to the appendix.
9. The selected parameters for cylinder flow are overly simplistic, only covering laminar flow cases. Generally, the Kármán vortex street phenomenon is more common in cylinder flows, yet the authors did not include this scenario.
10. All data used is 2D, and it's unclear whether this model can handle 1D and 3D experiments. The lack of such experiments significantly reduces the persuasiveness of the work.
11. Without knowing the scale of the data, reporting only L1 loss makes evaluation difficult. Could authors additionally report the relative L2 loss?
12. As the authors acknowledge, the inference time of diffusion models limits their application, which is confirmed by the statistical results. The authors should consider using inference acceleration methods such as DDIM and verify that the method remains effective under DDIM sampling.

Meta-review: The reviewers are divided (6-5-6-6-6-3) about the paper, but they overall lean towards acceptance. The paper introduces a new approach to physics simulations using latent diffusion models that can be conditioned on text prompts. Along the way, the paper introduces full 4d spatiotemporal generation and diffusion on arbitrary (non-regular) meshes. A number of concerns have been raised by the reviewers, and most of them have been addressed during the author-reviewer discussion period. The proposed changes include clarifications and new experiments that better investigate Text2PDE's capabilities.

The main concern that remains is with regards to the text conditioning capability of Text2PDE. Conditioning on text prompts is an interesting direction but makes the evaluation more challenging, as text descriptions are inherently fuzzy. To address this issue, a new dataset with 3d shapes has been proposed by the authors.

Overall, while the usefulness and validation of text conditioning may still be debated, the paper presents valuable contributions in the context of physics simulations using latent diffusion models. For these reasons, and given the overall positive reviews, I recommend acceptance. I encourage the authors to address the remaining concerns and to implement the modifications discussed with the reviewers in the final version of the paper.

Decision: Accept (Poster)