When does it pay to replace a PDE solver with a neural network? A back-of-the-envelope cost analysis with break-even formulae, scaling laws, and interactive calculators.

TL;DR

  • Break-even ≈ dataset size. A surrogate pays off after you use it roughly as many times as the number of training simulations. GPU training adds only a small overhead on top.
  • Accuracy is the real cost driver. Halving the target error can multiply the required dataset by 4–32×, due to a steep power law. Faster inference barely moves the economics.
  • Fine-tuning is the unlock. Starting from a pre-trained physics model cuts the break-even from thousands of queries to tens or hundreds.
  • Not a universal replacement. Surrogates shine for high-volume, moderate-accuracy tasks (e.g. shape optimization, parameter sweeps, uncertainty quantification, etc.). Keep the full solver for one-off or validation runs.

Background

Most of computational science and engineering runs on numerical solvers for partial differential equations (PDEs): methods that discretize a domain into a mesh with millions of cells and find a converged solution to the governing equations (Navier–Stokes, elasticity, Maxwell, heat transfer, etc.). These solvers are accurate and trustworthy, but expensive: a single industrial CFD or structural case routinely consumes hours on tens or hundreds of CPU cores. When a workflow requires running many of these simulations — shape optimization, design space exploration, uncertainty quantification, real-time control — cost quickly becomes the bottleneck.

AI surrogates offer a different trade-off. Instead of solving the equations each time, a neural network learns the solution operator: the map from problem parameters (geometry, boundary conditions, material properties) to the solution field. Architectures developed over the last few years — physics-informed neural networks [1], neural operators [2], mesh-based graph networks [3], transformer-based models [4] — have demonstrated that this map can be learned to useful accuracy, and that once trained, evaluating it takes seconds on a single GPU rather than hours [5].

However, this speed is not for free. The surrogate must first be bought: a training dataset must be generated by running the very solver we are trying to avoid, and the network must be trained on GPUs. The central question of this post is therefore an economic one, in the spirit of the cost–accuracy analysis of [6] and the break-even complexity framework of [7]:

Under which conditions does the total cost of building and using an AI surrogate fall below the cost of simply running the solver?

We will answer it with a small set of closed-form expressions, then make them tangible with some worked examples and interactive calculators.

Cost primitives

We need only a handful of quantities. The cost of one full solver run is

\[c_{\text{sim}} = t_{\text{sim}} \cdot n_{\text{cpu}} \cdot p_{\text{cpu}},\]

where $t_{\text{sim}}$ is the wall-clock time (typically hours), $n_{\text{cpu}}$ the number of cores, and $p_{\text{cpu}}$ the price per core-hour.

The cost of one surrogate inference is, analogously,

\[c_{\text{inf}} = t_{\text{inf}} \cdot n_{\text{gpu}} \cdot p_{\text{gpu}},\]

with $t_{\text{inf}}$ measured in seconds on (usually) a single GPU. Building the surrogate involves two upfront investments, related to data generation $C_{\text{data}}$ and model training $C_{\text{train}}$:

\[C_{\text{data}} = D \cdot c_{\text{sim}}, \qquad C_{\text{train}} \approx \kappa \, D \, E \, p_{\text{gpu}}.\]

$D$ is the number of training simulations, $E$ the number of training epochs, and $\kappa$ a constant GPU-time per-sample and per-epoch, which usually depends on sample size and model complexity. The first equation already suggests a key structural point that deserves emphasis: data generation is paid in the same currency as the thing being replaced — every training sample is a solver run. The GPU bill, in comparison, is usually the smaller line item here.

Break-even

Suppose that over its useful lifetime the surrogate will answer $N$ queries (design evaluations). The two competing total costs are

\[C_{\text{solver}}(N) = N \, c_{\text{sim}}, \qquad C_{\text{surr}}(N) = D \, c_{\text{sim}} + C_{\text{train}} + N \, c_{\text{inf}}.\]

The surrogate is the cheaper option if and only if $N > N^*$, with

\[N^* \;=\; \frac{D \, c_{\text{sim}} + C_{\text{train}}}{c_{\text{sim}} - c_{\text{inf}}}.\]

In practice $c_{\text{inf}} \ll c_{\text{sim}}$, so we can approximate the above expression:

\[N^* \;\approx\; D + \frac{C_{\text{train}}}{c_{\text{sim}}}.\]

This result is pleasingly interpretable:

The break-even point is approximately the dataset size itself, plus a training overhead measured in “simulation-equivalents”.

Another way of looking at it: once you have run enough simulations to train a surrogate and then need at least that many additional evaluations, the surrogate breaks even — and any query beyond $N^*$ is almost free. In design optimization or UQ studies where $N \gg D$ by orders of magnitude, the economics are overwhelmingly in favor of the surrogate.

The term $C_{\text{train}} / c_{\text{sim}}$ converts the GPU cost into units of solver runs. For typical industrial cases it amounts to a few tens of simulation-equivalents, while $D$ ranges from hundreds to tens of thousands. So the economics are essentially dominated by data generation, not by training. After the break-even point, every additional query saves essentially the full $c_{\text{sim}}$.

This analysis has been independently validated in [7], where the authors introduce break-even complexity as a formal metric and benchmark it across multiple PDEs, finding that surrogates become more cost-effective as problem complexity (dimensionality, Reynolds number, etc.) grows.

Cost ratio and savings

Break-even tells us whether the investment is recovered, but it is also useful to analyze how decisively the surrogate wins beyond that point. The natural quantity is the amortized cost per query,

\[c_{\text{eff}}(N) = \frac{D \, c_{\text{sim}} + C_{\text{train}}}{N} + c_{\text{inf}},\]

which starts enormous (the fixed costs divided by a handful of queries) and decays toward the inference price. Dividing by the solver’s per-query cost gives the dimensionless cost ratio

\[R(N) \;=\; \frac{C_{\text{surr}}(N)}{C_{\text{solver}}(N)} \;\approx\; \frac{N^*}{N} \;+\; \frac{1}{\rho}, \qquad \rho \equiv \frac{c_{\text{sim}}}{c_{\text{inf}}},\]

The table below shows different values of the cost ratio as a function of $N / N^*$, using a representative $\rho = 10^4$:

$N / N^*$ Cost ratio $R(N)$ Savings $1 - R(N)$ Interpretation
0.5 2.00 −100% Surrogate costs twice the solver
1 1.00 0% Break-even
2 0.50 50% Fixed costs recovered twice over
10 0.10 90% Typical single optimization study
100 0.010 99.0% Sustained, multi-project use
1,000 0.0011 99.9% $1/\rho$ starts to dominate
$\to \infty$ 0.0001 99.99% Asymptote $1/\rho$

Two things stand out from this analysis:

  1. First, the entire region any real project lives in (between parity and ~99% savings) is governed by the $ N^* / N $ term alone. The savings fraction $1 - R(N)$ hits 50% at $ N = 2N^* $, 90% at $ 10N^* $, and 99% at $ 100N^* $. Savings are earned in multiples of the break-even point — which is why estimating lifetime query volume in units of $N^*$ seems like a good practice.

  2. Second, the table is essentially independent of $\rho$. At any realistic volume, the cost ratio is governed by the fixed-cost term $ N^* / N $, not by the inference price. A practical corollary of this is that optimizing inference further barely moves the economics, since the lever that moves everything is data efficiency. Decreasing $t_{\text{inf}}$ changes essentially nothing on the cost side — its value lies elsewhere, as the next section argues.

Speedup

The raw speedup of a surrogate is

\[S = \frac{t_{\text{sim}}}{t_{\text{inf}}} \;\sim\; 10^3 \text{–} 10^5,\]

and the cost ratio per query $\rho$ is of the same order. As shown before, speedup alone does not decide the economics. If the lifetime query count $N$ stays below $N^*$, a million-fold speedup still loses money: the fixed costs are never amortized. Speedup tells you how fast the marginal cost goes to zero, not whether you recover the investment.

Speedup carries value that the cost model does not capture: latency. Results in seconds rather than hours enable workflows that are qualitatively different — interactive design sessions, optimization loops with thousands of evaluations, real-time digital twins, in-the-loop control. In these settings the surrogate is not just a cheaper solver, but an enabler of a workflow that would otherwise not exist. A complete business case may add a value-of-latency term to the comparison, but in this post we keep score in compute cost only, which makes our conclusions conservative.

Accuracy scaling

So far $D$ has been a free parameter. It is not: the surrogate is only useful if it is accurate enough, and accuracy is bought with data. Empirically, operator-learning models follow a power law [8] reminiscent of neural scaling laws in other domains [9]:

\[\varepsilon(D) = \varepsilon_0 \, D^{-\alpha}, \qquad \alpha \approx 0.2 \text{–} 0.5,\]

where $\varepsilon$ is a relative test error and $\varepsilon_0$ a problem- and architecture-dependent constant. Inverting for a target accuracy $\varepsilon_t$ gives the minimum dataset size

\[D_{\min}(\varepsilon_t) = \left( \frac{\varepsilon_0}{\varepsilon_t} \right)^{1/\alpha}.\]

Because $1/\alpha \approx 2$–$5$, the cost of accuracy is steeply convex: halving the target error multiplies the required dataset, and hence the break-even query count, by a factor of $2^{1/\alpha} \approx 4$–$32$.

Substituting back into the break-even point yields the complete decision rule:

\[\boxed{\; N^*(\varepsilon_t) \;\approx\; \left( \frac{\varepsilon_0}{\varepsilon_t} \right)^{1/\alpha} \;+\; \frac{C_{\text{train}}}{c_{\text{sim}}} \;}\]

A surrogate is economically and technically viable only when the following two conditions hold simultaneously: $N \geq N^*(D) $ and $ \varepsilon(D) \leq \varepsilon_t $.

The accuracy condition implies $D \geq D_{\min}$, and the economic condition implies $ N \geq D + \frac{C_{\text{train}}}{c_{\text{sim}}}$. In the worst case these requirements conflict: a high-accuracy application needs a large $D$, which raises the economic break-even. The good news is that, since $R(N)$ grows asymptotically without bound, larger $D$ only delays (not prevents) the break-even point.

The above expression shapes the entire applicability of Physics AI:

  • Surrogates are economically excellent in the moderate-accuracy, high-volume regime: design space exploration, optimization, Monte Carlo uncertainty quantification, screening studies.
  • They are economically poor in the high-accuracy, low-volume regime: final certification runs, one-off analyses, safety-critical sign-off — exactly where the traditional PDE solver should be retained anyway.

The natural industrial pattern is therefore a hybrid workflow: explore broadly and cheaply with the surrogate, then verify the handful of selected candidates with the full solver.

Fine-tuning

The break-even analysis changes character when a pre-trained model already exists — a foundation model for a physics domain, or an in-house model trained on a related product family. Starting from a pre-trained error $\varepsilon_{pt}$ on the new sub-domain, fine-tuning with $D_{ft}$ additional simulations improves accuracy along a curve of the form

\[\varepsilon_{ft}(D_{ft}) \approx \varepsilon_{pt} \left( 1 + \frac{D_{ft}}{D_0} \right)^{-\alpha'}.\]

with a warm-start constant $D_0$ and an exponent $\alpha’$ that benefits from the structure and patterns the model has already learned (operator regularity, geometry priors, physical invariances), making learning more effective during fine-tuning. If the new sub-domain is completely different, then $D_0 \to 0$ and $\alpha’ \to \alpha$.

The incremental break-even point is simply

\[N^*_{ft} \approx D_{ft} + \frac{C_{\text{train},ft}}{c_{\text{sim}}},\]

and since $D_{ft}$ is typically 10–100× smaller than training from scratch, fine-tuning moves the break-even from thousands of queries to tens or hundreds. This is the economic mechanism behind foundation-model-style Physics AI: the expensive pre-training is amortized across many applications, and each new use case pays only the marginal $D_{ft}$.

The above expression for the fine-tuning accuracy gain also admits a clean economically motivated stopping rule. Differentiating the full expression with respect to the number of fine-tuning samples:

\[\left| \frac{\partial \varepsilon_{ft}}{\partial D_{ft}} \right| = \frac{\alpha' \varepsilon_{pt}}{D_0} \left(1 + \frac{D_{ft}}{D_0}\right)^{-(\alpha' + 1)} = \frac{\alpha' \, \varepsilon_{ft}(D_{ft})}{D_0 + D_{ft}}.\]

Marginal accuracy per sample equals $\alpha’$ times the current error divided by the total effective data. Returns decay with exponent $\alpha’ + 1$ — strictly faster than the error itself — which is why fine-tuning eventually saturates. Diminishing returns are unavoidable. Doubling the dataset size from 500 to 1,000 simulation samples provides far more accuracy improvement than doubling from 5,000 to 10,000, since fine-tuning is most cost-effective early in the surrogate lifecycle and becomes increasingly inefficient as the model approaches its capacity limit.

Let $V(\varepsilon)$ denote the business value of operating at accuracy $\varepsilon$. Simulations should be added as long as the marginal value of accuracy exceeds the cost of a sample: $ \left| \frac{\partial \varepsilon_{ft}}{\partial D_{ft}} \right| \cdot V(\varepsilon) \;>\; c_{\text{sim}}.$ Assuming for simplicity a linear value of accuracy, $V(\varepsilon) = v$, the stopping condition can be solved in closed form for the optimal budget:

\[D_{ft}^{\text{opt}} = D_0 \left[ \left( \frac{v\, \alpha'\, \varepsilon_{pt}}{c_{\text{sim}}\, D_0} \right)^{\frac{1}{\alpha' + 1}} - 1 \right],\]

with the convention that a negative bracket means “do not fine-tune at all”: the zero-shot model is already past the point of diminishing returns relative to the simulation price.

The question is not “should I buy data?”. The question is: “how much data should I buy?”

Interactive examples

Enough theory, let’s see how the above analysis materializes with realistic numbers. The two calculators below let you explore the formulae using your own data.

Break-even explorer

Adjust the solver cost, dataset size and training budget, and watch the break-even point $N^*$ move.

Defaults correspond to a representative external-aerodynamics CFD case: $ t_{\text{sim}} = 8 $ h on 64 cores at 0.04\$ per core-h gives $c_{\text{sim}} \approx 20.5$\$. A dataset of $D = 2{,}000$ runs costs $\approx 41{,}000$\$; training for 384 GPU-hours at 2\$ per GPU-h costs $\approx 768$\$ — only 37 simulation-equivalents. The break-even lands at $N^* \approx 2{,}040$ queries. A single shape-optimization run (genetic algorithms or Bayesian optimization over a parameterized geometry) routinely needs $10^3$–$10^5$ evaluations, so one serious study can recover the entire investment.

Accuracy scaling explorer

Adjust the scaling exponent $\alpha$ and the target error $\varepsilon_t$ to see how the required dataset (and with it the break-even point) reacts.

Notice the convexity: moving the target error from 5% to 2.5% looks like a modest ask, but at $\alpha = 0.3$ it multiplies the required dataset by $2^{1/0.3} \approx 10\times$. The exponent $\alpha$, which is a property of the problem and the architecture, is arguably the most economically consequential number in the whole pipeline.

Decision framework

Collecting the pieces, the investment decision reduces to comparing two numbers:

\[\text{Build the surrogate} \iff N_{\text{lifetime}} \;>\; N^*(\varepsilon_t) \;\approx\; \left( \frac{\varepsilon_0}{\varepsilon_t} \right)^{1/\alpha} + \frac{C_{\text{train}}}{c_{\text{sim}}}.\]

In practice this unfolds into a short checklist:

  1. Estimate the query volume. Count the design evaluations you will realistically issue against this family of problems over the model’s lifetime — across optimization runs, parameter sweeps, UQ analysis, and what-if studies. If the answer is “a handful”, stop here and keep the solver.
  2. Set a realistic accuracy target. Decide what error is acceptable for the exploratory phase, not for final sign-off. The convexity of $D_{\min}(\varepsilon_t)$ punishes gold-plating the target.
  3. Estimate $D_{\min}$ and compare. Use pilot experiments or published scaling results for your architecture and problem class to estimate $\varepsilon_0$ and $\alpha$; a small pilot of 100–200 simulations at two or three dataset sizes is usually enough to fit the power law and extrapolate.
  4. Check the fine-tuning shortcut. If a pre-trained model covering your physics exists, redo the comparison with $D_{ft}$ instead of $D$ — the verdict often flips from “not worth it” to “obviously worth it”.
  5. Plan the hybrid loop. Budget solver runs for verification of surrogate-selected candidates; they mitigate the accuracy risk and feed future retraining.

The qualitative summary: the hypothesis that AI surrogates pay off is confirmed, conditionally. The condition is enough volume of queries during surrogate lifetime, with an accuracy target that respects the $\varepsilon^{-1/\alpha}$ cost curve. Out-of-distribution queries or shifts in design spaces (which force retraining) are practical issues that push $N^*$ upward, so they should be considered in a real business case.

Conclusions and final considerations

Three lessons stand out from the math:

  1. The break-even point is measured in queries and roughly equals the dataset size. The intuition “I must use the surrogate about as many times as the simulations I trained it on” is essentially exact, because GPU training adds only a small simulation-equivalent overhead.
  2. Accuracy — not GPUs — is the economic enemy. The $\varepsilon^{-1/\alpha}$ blow-up frames Physics AI as a moderate-accuracy, high-throughput technology, with the classical solver retained for verification. The hybrid workflow is not a compromise; it is the economically optimal design.
  3. Fine-tuning is the economic unlock. Pre-trained physics models shift the break-even by one to two orders of magnitude, which is what makes the investment case work even for teams without massive design campaigns. Recent studies [10] have already provided estimates for dataset and model size requirements to achieve foundation models in certain physics AI domains.

Everything above treats the training dataset as $D$ undifferentiated samples, as if every simulation were equally informative. It is not — and this is where the largest untapped savings live. The same accuracy can often be reached with a fraction of the data by choosing the simulations wisely: space-filling and adaptive sampling over the design space, active learning that queries the solver where the surrogate is most uncertain, multi-fidelity strategies that mix cheap coarse-mesh runs with a few expensive fine ones, and exploiting symmetries to multiply effective dataset size at zero solver cost. Each of these attacks $\varepsilon_0$ and $\alpha$ directly, bending the most expensive curve in this post. A clever data generation strategy is, in effect, the cheapest way to buy accuracy — and a topic that deserves a post of its own.

References

[1] M. Raissi, P. Perdikaris, G. E. Karniadakis. Physics-informed neural networks: A deep learning framework for solving forward and inverse problems involving nonlinear partial differential equations. Journal of Computational Physics, 378:686–707, 2019.

[2] L. Lu, P. Jin, G. Pang, Z. Zhang, G. E. Karniadakis. Learning nonlinear operators via DeepONet based on the universal approximation theorem of operators. Nature Machine Intelligence, 3:218–229, 2021.

[3] T. Pfaff, M. Fortunato, A. Sanchez-Gonzalez, P. Battaglia. Learning Mesh-Based Simulation with Graph Networks. International Conference on Learning Representations (ICLR), 2021.

[4] Wu, H., Luo, H., Wang, H., Wang, J. & Long, M. Transolver: A Fast Transformer Solver for PDEs on General Geometries. Proceedings of the 41st International Conference on Machine Learning (ICML), 235:53681-53705, 2024.

[5] D. Kochkov, J. A. Smith, A. Alieva, Q. Wang, M. P. Brenner, S. Hoyer. Machine learning–accelerated computational fluid dynamics. Proceedings of the National Academy of Sciences, 118(21), 2021.

[6] M. V. de Hoop, D. Z. Huang, E. Qian, A. M. Stuart. The Cost-Accuracy Trade-Off in Operator Learning with Neural Networks. Journal of Machine Learning, 1:299-341, 2022.

[7] Y. Zhang, N. Roberts, T. Marwah, M. Khodak. Breakeven complexity: A new perspective on neural partial differential equation solvers. arXiv:2605.15399, 2026.

[8] K. Azizzadenesheli, N. Kovachki, Z. Li, M. Liu-Schiaffini, J. Kossaifi, A. Anandkumar. Neural operators for accelerating scientific simulations and design. Nature Reviews Physics, 6:320–328, 2024.

[9] J. Kaplan, S. McCandlish, T. Henighan, et al. Scaling Laws for Neural Language Models. arXiv:2001.08361, 2020.

[10] N. Ashton, J. Brandstetter, S. Mishra. Fluid Intelligence: A Forward Look on AI Foundation Models in Computational Fluid Dynamics. arXiv:2511.20455, 2025

Disclaimer: This post was created with the assistance of Claude (Anthropic’s AI) to help structure my ideas, polish the text or generate interactive plots. That said, all content is reviewed and edited by the human author before publication.