acceptodds
Under review as a conference paper at ICLR 2027

EvoState: Predicting Spatiotemporal Physical Dynamics with Hierarchical Latent States

Abstract

Autoregressive prediction of physical dynamics raises a basic design question: which latent states should persist across steps, and which can be recomputed? We introduce EvoState, which separates hierarchical representation learning, latent evolution, and physical readout. Its transition model jointly advances Fine, Middle, and Coarse states, while a fixed readout reconstructs physical fields from Fine. On The Well's shear-flow benchmark, the 11.2M-parameter system achieves Test VRMSE of 0.349 over steps 6–12 and 0.657 over steps 13–30, below the published benchmark baselines. On a common validation panel, EvoState also achieves lower rollout error from step eight onward than three 140M-parameter Walrus-style models trained on shear flow alone, reaching 0.608 NRMSE at step 64 compared with 1.161–2.412. In a two-epoch, single-seed comparison under a matched training schedule, recomputing coarse states from Fine or omitting them increases mean paired per-window 64-step NRMSE by 20.9% and 23.7%, respectively, relative to carrying all three levels. Recomputing coarse states at inference brings them closer to true-frame encodings but worsens physical predictions. These results favor carrying jointly evolved states under the evaluated training recipe and show that same-frame latent accuracy alone is insufficient to assess their utility for an already-trained transition.

Primary area:
applications to physical sciences (physics, chemistry, biology, etc.)
Keywords:
Spatiotemporal Physical Systems, Latent Dynamics Modeling, Hierarchical Representation Learning, Scientific Machine Learning

Reviews

Among:
Shape:
1234this paper, Bottom 27%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.00 over 4 reviews, above 27% of the others.
Reviewer_fAPCOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The authors their EvoState model that predicts physical dynamics by jointly evolving fine, middle, and coarse latent states, then reconstructing physical fields from the fine state using a frozen decoder. Its three-stage framework separates representation learning, dynamics training, and readout.

Critical strengths
  1. Promising results with relatively few parameters: The 11.2M-parameter model achieves good long-horizon predictions compared with baseline Walrus-SF models. This suggests a good direction for parameter-efficient physical forecasting.

  2. Clear, modular training framework. The paper separates hierarchical representation learning, latent dynamics, and physical readout into three (intuitive) stages. Freezing the encoder and readout during dynamics comparisons helps assess changes in the transition model.

  3. A relevant architectural question: Investigating whether coarse latent states should persist across transitions or be recomputed addresses a useful design choice in autoregressive physical modeling that the authors pointed it with ablation.

  4. Detailed prediction diagnostics: Beyond aggregate errors, the paper examines individual physical channels, parameter regimes, predicted fields, and spectral behavior.

Critical weaknesses

I write the main weakness that authors may address:

  1. Limited distinction from close prior work: HEAP[1] already jointly evolves a hierarchy of latent states which is pretty similar to yours. Given that one of your claim is you novel architecture for spatial connection, I would suggest you clarify your architecture additional contribution and (if possible) provide a comparison with this related approach (otherwise, to me, it will be blurry if your architectural addition is necessary or only marginal).

  2. Confounded feedback and supervision changes: The coarse-state ablations that you are proposing change both recurrent feedback and the supervision path, including gradients into Fine. Then I think the the results do not isolate whether the improvement comes from carrying coarse states or from differences in optimization (because the gradient flows back through coarse anyway). Any idea to isolate it?

  3. Unequal training exposure and rollout supervision: Walrus-SF receives different training windows size (around 24k), which is fewer than one EvoState epoch. EvoState trains for seven epochs with explicit long-horizon supervision. Comparable long-horizon training is not clearly documented for Walrus-SF. These differences then could explain part of the performance gap. In the current format the outperformance might simply coming from larger seen windows in training.

  4. Insufficient architectural ablation and sensitivity analysis: The choices of spatial resolutions, attention-window sizes, encoder depths, and mask tiles require further justification. In particular, comparing number of levels would establish the benefit of the selected hierarchy and its sensitivity to configuration (i.e. why choosing 3 levels and not more/less?).

  5. Insufficient justification and transferability analysis of loss weights: The loss components have intuitive motivations, but their relative weights and normalization constants does not have sufficient justification and more importantly sensitivity analysis. The selected hard coded constant weights raise the question weather your model need to be tuned per dataset or not?

[1]- https://arxiv.org/html/2505.18857v1

Questions for authors

Please see the weaknesses specifically related to HEAP related work and its relation to your work as well as sensitivity analysis.

4 comments
AuthorsOpenReview ↗

Response to Reviewer fAPC : HEAP, carry versus supervision, and fairness

Thank you for the detailed reading, the strengths you list, and the pointer to HEAP. The revision discusses HEAP, adds Walrus-architecture predictors matched in parameters and training windows, separates the organization of the coarser levels from their supervision as you suggested, and adds TRL2D and further generalization tests. W4 and W5 follow in a second comment.

W1: How does EvoState differ from HEAP?

Answer: In what the coarser levels are for. HEAP's decoder reads all levels, so its coarser levels serve both representation and dynamics. EvoState reads out from Fine alone, so Middle and Coarse act only through the dynamics, and their role can be tested with encoder and readout fixed.

Learning the levels. HEAP trains a hierarchical reconstruction autoencoder, then a predictor on its frozen level embeddings. EvoState learns the three levels jointly with a cross-level-aligned same-frame masked-feature (JEPA) objective; each level keeps structure inferable from the same frame, without pixel reconstruction. Section 2 discusses HEAP.

Evidence (shear flow, Section 5.4).

  • Organization. Carry gives the lowest long-horizon error. With everything else fixed (2-epoch variants), per-step recompute raises error over carry by 27.4% and 20.9% at steps 32 and 64, and Fine only by 29.8% and 23.7%; all four intervals exclude zero (Fig. 6, Table 18).
  • Single-level intervention. A change in Coarse is barely visible at step 1 but about 17 times larger by step 32, at low frequencies; a change in Fine is largest at step 1 and then decays (Fig. 21).

What this shows: the coarser levels act on slow, low-frequency structure. HEAP has no public code and its data are available only on request, so we discuss it rather than reproduce it.

W2: Feedback and supervision changed together. Can they be separated?

Answer: Yes, and the experiments favor carry. On TRL2D we vary write-back and coarser-level supervision separately: with the carried levels supervised, as in EvoState, carry has the lowest error of all five variants at steps 8 and 16 (Table 24, Appendix D.8). On shear flow, replacing the carried coarser levels at inference, with weights and gradients unchanged, raises step-64 error by 113% (Fig. 20): the trained transition relies on the coarser levels it evolved.

Five variants (TRL2D, 24 Valid windows, Table 24). Four-channel mean NRMSE at step 8 / step 16. Within a row only the written-back states differ, which also changes the gradient path into Fine:

Coarser-level lossCarryPer-step recomputeFine only
Yes (EvoState)0.228 / 0.3260.242 / 0.347—
No0.262 / 0.4480.252 / 0.3550.247 / 0.371

What this resolves: with the supervision EvoState uses, carry is the best organization; without coarser-level losses (not EvoState's method), the unsupervised carried states drift.

W3: Training exposure and long-horizon supervision differ. Is the gap unfair?

Answer: With training windows matched, the conclusion stands. Walrus-architecture predictors, trained on a one-step objective, are more accurate over the first steps, and the two are close over steps 13–30; over longer rollouts EvoState stays bounded, runs faster, and keeps amplitude closer to the truth. Each predictor keeps its own objective, so this comparison tests the whole design; the hierarchy is tested inside EvoState (W1). On TRL2D, EvoState trains on rollouts of only four steps yet has lower error from step 6 on and keeps amplitude closer to the truth at step 64, so its long-horizon advantage does not come only from long training rollouts.

Fair comparison. The submitted Walrus-SF models (24,576 windows each) only motivate the question (Section 1). Walrus-SF-12M and Walrus-TRL-12M use Walrus's official code on the same splits, match EvoState in parameters and training windows, and get the same four input frames at evaluation.

EvoState vs Walrus (12M)VRMSE, steps 6–1213–3031–64Step-64 amplitude ratio (truth = 1)
Shear flow0.261 vs 0.1910.508 vs 0.5110.776 vs 1.3600.89 vs 1.31
TRL2D0.448 vs 0.5990.848 vs 1.1001.245 vs 1.4001.03 vs 0.26

What the numbers mean. At step 64 on shear flow, EvoState's error is less than half (0.835 vs 2.060), with divergence 0/112 vs 4/112; at 512 steps it is 1/112 vs 63/112.

Lower error, damped field. In an illustrative TRL2D Test window (t_cool = 0.56, step 12, both trained on all conditions), Walrus-TRL-12M has lower VRMSE (0.180 vs 0.221) but smooths the interface away: amplitude ratio 0.59 vs 1.03, with similar correlation (0.26 vs 0.29). Over steps 4–16 of TRL2D density, Walrus VRMSE is within 1.1× EvoState's in 75 of 117 window-step pairs, and 50 of these are structurally clearly worse (Section 5.2, Appendix C.8).

Speed. 8.1 vs 15.6 ms (shear flow) and 6.7 vs 16.6 ms (TRL2D) per step.

AuthorsOpenReview ↗

Number of levels and loss weights

W4: Why three levels? Were other design choices tested for sensitivity?

Answer: The three levels are the three stages of the encoder and suffice for the paper's core question; we placed the experiments where they decide that question.

The three levels are the three stages of the Swin V2 encoder (depths 2/4/2, channels 32/64/128). Fine feeds the readout and the coarser levels serve only the dynamics; Middle sits between them, so the coarsest level is not tied directly to the finest. The core question is whether the coarser levels should evolve as state, and our experiments target it: matched comparisons of how the coarser levels are organized, and a second system. The number of levels, per-level resolution, attention window, encoder depth, and mask tile are fixed, and Section 6 states this scope.

W5: Do the loss weights need per-dataset tuning?

Answer: The loss weights do not. Both systems use the same weights, without per-dataset tuning or sweeps; only the training schedule is set per system, and only on Valid.

The revised objective has three weights: 1 for Fine, because the readout uses Fine, and 0.25 each for Middle and Coarse. Both systems share the architecture and these weights; normalization uses per-channel Train statistics, which are computed rather than tuned. The two extra terms of the submitted full model had coefficients fixed before training (ranking 0.1; Persistence-relative 0.5 with ε = 0.05); we dropped them so that all comparisons use one objective, Eq. (5). What differs per system: update counts and batch sizes follow dataset size, the Stage B training horizon follows τ, and on TRL2D the training length, learning-rate schedule, and latent-history noise were chosen on Valid (Appendix B.3). With the same weights, EvoState also holds its accuracy on cooling times held out of transition-model training (Section 5.3).

What this resolves: one set of weights works on two systems whose decorrelation times differ widely and on held-out conditions, which is itself a test of transferability.

AuthorsOpenReview ↗

Response to Reviewer fAPC: Walrus-SF-140M trained with the same number of windows

Thank you for your thoughtful review and for pointing out the unequal training exposure. We have now completed the experiment that addresses it.

W3: training exposure. Walrus-SF-140M has been trained to its full schedule on the v2 split. It uses the same number of training windows as EvoState (1,084,160), the same official code and one-step-ahead objective as Walrus-SF-12M, and the architecture of the N = 32 model in Figure 1, with 140M parameters, about 12.5 times EvoState's 11.2M. Test was evaluated once at the training endpoint.

Results. Even against a predictor 12.5 times its size, EvoState keeps its advantage once the flow decorrelates. We compare the two along the four dimensions used in the revision: pointwise error, field structure, numerical stability, and cost per step (Section 4). Walrus-SF-140M is more accurate over the first steps and has the lower four-channel mean error in every range. From steps 13–30 onward, however, EvoState has the lower error in most windows (78 of 112 over steps 31–64) and the lower window median in every range (0.299 vs 0.567 over steps 31–64; Table 20). Its tracer error is also lower (Appendix C.4), as is its error on both velocity components over steps 31–64 (Table 14). Its perturbation correlation and amplitude ratio are closer to the truth, which means that its vortices are closer to their true positions and strength. Neither EvoState nor Walrus-SF-140M diverges, and EvoState needs only about 1/32 of the time per step on the same GPU (7.2 vs 229 ms).

Shear-flow v2 Test (112 windows). Mean VRMSE; per-channel columns and the median cover steps 31–64; r and a are window medians at step 64; best per column in bold. Time per step: EvoState 8.1 vs Walrus-SF-12M 15.6 ms; EvoState 7.2 vs Walrus-SF-140M 229 ms on the same RTX 4090.

ParamsFour-channel, steps 13–30Four-channel, 31–64Four-channel, step 64r / a, step 64PressureTracerVelocity x / yMedian
EvoState11.2M0.5080.7760.8350.820 / 0.8861.6610.3940.124 / 0.9240.299
Walrus-SF-12M12.0M0.5111.3592.0600.333 / 1.3132.1480.6340.251 / 2.4040.801
Walrus-SF-140M140M0.4470.6450.7270.550 / 0.6750.9370.5000.134 / 1.0090.567

What the fields show (Appendix C.4). The pressure gap is concentrated in 21 windows in which the true pressure is nearly uniform. VRMSE divides by a near-zero variance there, and these windows account for 81% of EvoState's summed pressure VRMSE. Without them, EvoState has the lower four-channel mean over steps 31–64 (0.340 vs 0.513; Table 14), and in standardized units its pressure RMSE is the lowest of the three models (RMSE 0.027, against 0.051 for Walrus-SF-140M and 0.085 for Walrus-SF-12M). In an example window with structured pressure, EvoState keeps the four low-pressure vortex cores up to step 64, whereas both Walrus-architecture predictors smooth them out (Fig. 11). Walrus-SF-140M does not overestimate the perturbation amplitude as Walrus-SF-12M does (four-channel a at step 64: 0.675 vs 1.313; Table 2). In the Test example window of Fig. 3a, however, it stretches the tracer vortices into filaments, while EvoState matches their number and positions (Fig. 12); over all windows, its tracer r at step 64 is only 0.12. For this reason we report pointwise error throughout but, once predictions decorrelate from the truth, read it together with structure and the fields. Pointwise error mixes errors in position and amplitude (Section 4), and after decorrelation a few windows can dominate its mean.

Exposure and supervision. With the number of windows matched, the main remaining difference in training is the objective: the Walrus-architecture predictors are trained one step ahead (with six history frames, as in the official setup), whereas EvoState is trained on multi-step rollouts; both receive four frames at evaluation. This difference is part of the design being compared (Section 4). The role of the hierarchy itself is tested within EvoState under a single training setup (see our responses to W1 and W2; Section 5.4).

The revised PDF adds these results to Table 2, Section 5.1, and Appendix C.4 (Table 14, Figs. 11–13), with the timing in Table 24 and the unified comparison in Table 20.

We hope this, together with the controls described in our first response, addresses W3. If any concern remains, we would be glad to answer before the discussion closes.

Reviewer_fAPCOpenReview ↗

post rebuttal

Thank you for the clarification and efforts you did in your rebuttal.

The concerns in my original queries addressed. The remaining concern is the diversity of your experiment. I can understand that in dynamical systems and PDE community solving simulated systems is common practice, but reviewer v74v concern is also not off. Many approaches test on real word data as well as simulated databases, e.g. ERA5.

Besides, the baseline examples you provided like Poseidon or Walrus, although targeting simulated dataset, but have more diversity including waves, plasma, chemical reaction, etc. instead of restricting to 2 fluid cases.

Thus the generalization of Evostate to even different simulated dynamical systems remains questionable. Please take a look to Well benchmark as an example.

Given this, I give borderline score to the rebuttal version. It is up to AC to weigh toward accept or reject.

Reviewer_v74vOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes EvoState, a framework that helps answer which latent states should persist across steps in autoregressive prediction of physical dynamics. EvoState decouples three components: a hierarchical Swin-style encoder pretrained with a same-frame masked JEPA objective, a periodic ConvNeXt U-Net that jointly advances Fine, Middle, and Coarse levels, and a frozen Fine-only physical readout. With the encoder and readout fixed, the central ablation varies only the coarse-state feedback rule, comparing carried, recomputed, and absent coarse levels on The Well shear flow. The results suggest that carrying jointly evolved coarse states, rather than recomputing or omitting them, lowers long-horizon rollout error, and that the full model improves on both the published The Well baselines and much larger Walrus-SF models from step eight onward.

Critical strengths

S1: The paper is clean and easy to understand, and it poses a focused and practically relevant design question of whether coarse latent levels should be carried or recomputed between transitions.

S2: The ablation design is well controlled, with only the feedback rule of Eq. (4) varies, while all other components held fixed.

Critical weaknesses

W1: There appear to be inconsistencies between the paper and the released code: for example, the Stage B objective omits the Persistence-relative term of Eq. (5) (stage_b_latent_dynamic/objective.py), and the curriculum is short-only for the first two epochs before adding long horizons on every tenth batch (data.py and clock.py), whereas the ablation in Appendix C.1 and Fig. 6c relies on a 75/20/5 short/medium/long mix after half an epoch. Since the Stage B weights and the evaluation harness used for the reported Valid and Test results are also not included, the reported results cannot currently be reproduced from the supplement.

W2: All experiments use a single simulated dataset, The Well shear_flow, whose 28 Re-Sc conditions all appear in the training. The evaluation does not cover unseen parameter regimes, other physical systems, or noisy or real-world observational data. Consequently, the broader generalizability suggested by the title and opening question, as well as the practical applicability of the approach, remains to be demonstrated.

Questions for authors

Q1: Could the authors evaluate the proposed method, ideally including the carried-state versus recomputed comparison, in at least one additional setting, such as a held-out Re-Sc condition, a real-world dataset, or observations perturbed with noise? Even a single such experiment would help demonstrate whether the carried-state advantage extends beyond interpolation within the shear-flow example.

Q2: The paper would benefit from more consistent terminology and clearer cross-referencing. For example, the third term in Eq. (5) is initially referred to only as “the last term” and is not identified as the “persistence-relative term” until Section 4 and the Appendix. Similarly, the notation “H4→h1 windows” (Section 4, Appendix A.2) is never defined. Could the authors introduce and define these terms at their first occurrence?

Q3: Could the authors report the variance of the results? Such information on training variability would help inform how robust the carried-state advantage is.

Q4: Could the authors explain how were the 28.6% (h = 1) and 9.4% (h = 8) reductions in Introduction obtained from reported results?

3 comments
AuthorsOpenReview ↗

Response to Reviewer v74v : code consistency and a second system

Thank you for reading the paper closely and checking the uploaded code; your comments have made both stronger. In the revision we retrain and evaluate shear flow on the official corrected v2 split, add a second physical system, TRL2D, and compare with Walrus-architecture predictors of comparable size trained on the same number of windows. We also test rollouts beyond the training length, degraded inputs, and held-out cooling times, and release a first version of the code and weights. W1, W2, and Q1 are answered here; Q2 to Q4 follow in a second comment.

W1: Code and paper are inconsistent

Answer: Paper, code, and weights now match: every newly trained model in the revision uses only the revised Eq. (5), and the code and weights behind each table are released. The two differences you found were real.

Where they differed. The supplement's objective.py has the ranking term but not the Persistence-relative term of the submitted Eq. (5), and clock.py/data.py train only on short horizons for two epochs, then add a long horizon every tenth batch. The submitted numbers come from our archived research code: the full model used the ranking and Persistence-relative terms, and the ablation (submitted Fig. 6c) used regression alone. The supplement held an incomplete version of the former, without the Persistence-relative term, the ablation recipe, the Stage B weights, or the evaluation harness.

Supplement defaultSubmitted ablation (Fig. 6c)Revised shear-flow model (v2)
ObjectiveRegression + rankingRegressionRegression
HorizonsShort only for 2 epochs, then long every 10th batchShort for 0.5 epoch, then 75/20/5 short/medium/longSame as ablation

What the revision does. So that all comparisons use one objective, we dropped the ranking and Persistence-relative terms. Every new model uses the weighted latent regression of the revised Eq. (5) (Fine/Middle/Coarse weights 1/0.25/0.25), and none of the 112 v2 Test rollouts on shear flow diverges within 64 steps. The revision also states that the submitted per-step recompute and Fine-only variants change where the coarser-level losses act as well as what is written back (Section 4, Appendix D.1), and gives the gradient truncation (Section 3.2).

Code and weights. A first version is in an anonymous repository (https://anonymous.4open.science/r/evostate-release-B06D/): archived code for both recipes, training and evaluation code for every model in the revision, and the Stage B weights behind the reported tables. The complete release will follow before the discussion closes (November 18).

What this resolves: every newly trained model uses the revised Eq. (5); the inference-time replacement experiment keeps the submitted reference model, as the paper states.

W2, Q1: Only one dataset. Do the results extend beyond the training distribution?

Answer: Yes. As you note, even one additional setting helps; the revision adds three, covering held-out conditions and noisy observations, and repeats carry vs per-step recompute on the new system. The held-out test is on TRL2D only.

  • Another physical system. TRL2D, a radiatively cooled turbulent mixing layer from The Well, decorrelates within 3 to 5 frames. It uses the same loss weights as shear flow, settings were chosen on Valid, and Test was evaluated once. EvoState (mean of two independent training runs) reaches 0.448 and 0.848 VRMSE over steps 6–12 and 13–30, below CNextU-net, the best published baseline (0.54 and 1.01), with no numerical divergence (Section 5.1). Meaning: the result is not specific to shear flow.
  • Held-out cooling times. On TRL2D, with every trajectory of one cooling time (0.32 or 3.16) removed from transition-model training, error stays within 10% of the all-condition model (+7.8% and −5.7%). The encoder and readout saw all cooling times, so this tests how the dynamics generalize. Retrained the same way, the Walrus-architecture predictor has higher error at 0.32 (0.680 vs 0.572 over steps 1–16, EvoState lower on 9 of 10) and is close at 3.16 (0.575 vs 0.565, 6 of 10) (Section 5.3). Meaning: the transition model works on cooling times it never saw in training.
  • Noisy observations. On shear flow, with noise, missing data, outliers, or stripes in the four input frames, EvoState's error over steps 13–30 grows less than Walrus-SF-12M's in all eight settings, e.g. 1.73× vs 8.16× at 10% noise (Section 5.3). Meaning: EvoState degrades more slowly when observations are corrupted.
  • Carry vs per-step recompute. On TRL2D, varying write-back and coarser-level supervision separately, carry with supervised coarser levels, as in EvoState, has the lowest error of five variants at steps 8 and 16 (Appendix D.8).

What this resolves: the evidence now covers another system, held-out conditions, and noisy observations, and the shear-flow main results use the copy-free v2 split (VRMSE 0.508 over steps 13–30).

AuthorsOpenReview ↗

Terminology, variance, and the introduction numbers

Q2: Inconsistent terminology and cross-references

Answer: Thank you; they are now consistent.

"H4→h1" meant four history frames and one target frame; the revision spells this out instead of using the abbreviation. The "last term" of the submitted Eq. (5) was the Persistence-relative term; the revised Eq. (5) contains only the weighted regression. Text, tables, and captions now use one name per concept; for example, carry, per-step recompute, and Fine only name the three organizations of the levels.

Q3: How large is the variance?

Answer: On TRL2D, both independent training runs are below the best published baseline in every interval.

We trained Stage B on TRL2D twice independently and evaluated each run once on the official Test set: VRMSE is 0.442 and 0.455 over steps 6–12 against 0.54, and 0.889 and 0.807 over steps 13–30 against 1.01 (Appendix C.1). The intervals in the paper bootstrap paired per-window differences with the 28 physical files as clusters, so they measure evaluation uncertainty, not training variability (Appendix D.2); each submitted arm was trained once.

Q4: Where do the 28.6% and 9.4% in the introduction come from?

Answer: From unrounded validation means of the N = 16 and N = 64 Walrus-SF-140M models of Fig. 1 (v1 split).

Both models were trained on 24,576 windows and evaluated on the same 336 validation windows. Change = (N64 − N16)/N16; four-channel mean NRMSE:

StepN = 16N = 64ChangePaired 95% CI
10.0455030.032478−28.62%[−32.87%, −24.72%]
80.2031880.222351+9.43%[+1.22%, +17.21%]

The submitted appendix lists these values to three decimals, which gives 30.4% at step 1; the gap is rounding.

AuthorsOpenReview ↗

Response to Reviewer v74v: extrapolation to a higher Reynolds number, and the code release

Thank you again for your detailed review. Before the discussion closes, we add the two items promised in our response.

W2, Q1: a condition absent from training. In our first response we held out cooling times on TRL2D. Here we follow your suggestion of a held-out Re–Sc condition in a stricter form: we hold out an entire Reynolds number, the highest one (Re = 5×10⁵), together with all seven Schmidt numbers. This goes beyond interpolation, because the transition model must now extrapolate to a higher Reynolds number than any it was trained on. We retrained EvoState and Walrus-SF-12M without this condition to the same fixed endpoint and evaluated Test once. Since the encoder and readout saw the condition only as single frames, the experiment tests the transition model. As in the revised paper, we report pointwise error together with field structure; the perturbation correlation r measures whether the predicted vortices sit where the true ones are (Section 4).

Extrapolated operating condition Re = 5×10⁵, 28 trajectories per split. Mean VRMSE and perturbation correlation r (window median) at steps 13–30 / 31–64 / 64 (Tables 19 and 23).

SplitModelFour-channel meanTracerrEvoState lower
ValidEvoState0.548 / 0.904 / 0.9490.250 / 0.373 / 0.4090.849 / 0.837 / 0.78517 / 26 / 27
Walrus-SF-12M0.478 / 1.289 / 1.8590.298 / 0.525 / 0.5830.762 / 0.522 / 0.375
TestEvoState0.542 / 0.804 / 0.8310.346 / 0.506 / 0.5460.868 / 0.824 / 0.79321 / 24 / 26
Walrus-SF-12M0.528 / 1.239 / 1.7460.441 / 0.698 / 0.7580.792 / 0.457 / 0.257

The results follow the same pattern as with all conditions in training. Walrus-SF-12M is more accurate over the first steps. Over steps 13–30, EvoState's mean error is still higher (by 3% on Test and 15% on Valid), but its window median is already lower and its r higher, meaning that its vortices are closer to the true positions. From steps 31–64 onward, EvoState also has the lower mean error. By step 64, the error of Walrus-SF-12M is about twice that of EvoState, and its r has dropped to 0.26–0.38, against 0.79 for EvoState. The fields show why (Fig. 4c; Appendix C.9): EvoState rolls the tracer up into billows at the true vortex positions and keeps them up to step 64, whereas Walrus-SF-12M remains at flattened lobes that never fully roll up. Neither model diverges. From steps 13–30 onward, EvoState also has the lower tracer error in every range (Table 19), and holding out the condition barely affects it: its tracer error stays within 3% of that of its counterpart trained on all conditions.

Both datasets reuse initial states across conditions (Appendix A.1). The Reynolds number held out here and the cooling times held out in our first response therefore test the same question: whether the transition model evolves the flow correctly under a parameter it has not seen in training.

W1: code. The anonymous repository (https://anonymous.4open.science/r/evostate-release-B06D/) now contains the code, configurations, and weights of every model we trained and report in the revision. These include the main comparisons (Table 2, including Walrus-SF-140M), the long-rollout and degraded-input tests, both operating conditions, the write-back variants on both systems (Appendices D.1–D.6 and D.8), the token-grid sweep of Fig. 1, and the Section 5.4 auxiliary-loss variant, for which we release the archived objective containing the Persistence-relative term you pointed out. The repository also includes the evaluation harness and the fixed evaluation panels. AVAILABILITY.md lists what is not included: end-to-end replay outputs, confidence intervals clustered by initial velocity (an analysis we did not perform), the optimizer and RNG states needed to continue the v1 donor runs exactly, and the runner of the Appendix D.7 intervention, whose geometry and model are included.

In your Q1 you noted that even a single additional setting would help. The revision now adds a second system, an interpolated and an extrapolated operating condition, degraded inputs, and the write-back control on TRL2D. We hope this addresses W1, W2, and Q1, and we would be grateful if you could take it into account in your final assessment. If anything remains unclear, we will answer before the discussion closes.

Reviewer_RzBVOpenReview ↗
Rating
1
Confidence
4
Informativeness
1
Presentation
1
Soundness
1
Read review
Paper summary

I think the authors are trying to create EvoState to be a model for long-horizon forecasting of 2D fluid flow. It is tested on the shear-flow dataset from The Well benchmark. Its central question is which parts of a model’s internal state should be carried from step to step during a rollout, and which can be recomputed fresh at each step, and at what resolution will benefit most.

The authors first train three 140M-parameter Walrus-like transformers that differ only in token-grid density (16×16, 32×32, 64×64). The densest grid gives the best one-step prediction, but it is worse by step 8 and much slower. While this is only tested on shear flow, the authors like to suggest that token grid density is not a determining factor for long term rollout.

Then the authors then trained EvoState which is a significantly smaller model that includes three different components, which are decomposed into a pre-training JEPA like encoder, and then a latent evolution with a U-net where each level is being fed a different range of frequency (or resolution) , and then finally a decoder.

Evostate is better than similar sized benchmarks listed in the Well, but is not competitive against foundation models.

Critical strengths

Due to the difficulty to understand the paper and the fact that it is only tested on one single type of fluid flow, I have a hard time understanding whether the paper has provided new insights or whether the insight maybe somewhat generalizable.

Critical weaknesses

The contribution of the paper is fairly unclear, due to difficulty to understand, so it is hard to tell what is actually a contribution.

It is reflected even in the end of the introduction, apart from the first listed contribution, the next few are not really contributions.

Furthermore, due to the fact that the model EvoState has only been tested on shear flow, it is very hard to expect this behavior is somewhat generalizable beyond one single dataset at one particular set of metrics.

Questions for authors

I have the following list of questions for the authors:

a/ Would you mind clarify the writing of the full paper? It is extremely hard to read for a normal human. b/ Please consider trying Evostate on other dataset beyond ShearFlow and potentially some flow that has a different scale dependence. c/ Please consider describe what you did to create Walrus-Style transformer in more details? d/ Please comment on generalizability of the Evostate model

3 comments
AuthorsOpenReview ↗

Response to Reviewer RzBV : summary, contributions, and clarity

Thank you for the review. We revised the paper building on the original manuscript and the supplementary experiments, and added a second physical system, TRL2D; substantive changes are marked in blue in the revised PDF. The revision also moves shear flow to the official corrected v2 split, adds Walrus-architecture predictors of comparable size, tests rollouts beyond the training length, degraded inputs, and held-out operating conditions, and releases a first version of the code and weights.

Three points in the summary: Are the model and the comparison as summarized?

Answer: Three points need clarification, and the revision rewrites the passages behind them.

  1. The levels are learned, not band-pass inputs. Fine, Middle, and Coarse are the outputs of the three stages of one Swin V2 encoder, which is trained on single frames and then frozen (Section 3.1).
  2. We compare with task-specific models trained on the same system: The Well's published baselines and, new in the revision, a Walrus-architecture predictor of comparable size on each system (Section 5.1). Foundation models pretrained on many datasets are one to two orders of magnitude larger, so comparing with them would measure pretraining scale. The paper asks how the state should be organized, so we compare at matched parameters and training windows.
  3. The token-grid density experiment only motivates the question (Section 1); it is not a conclusion of the paper.

W1, W2: What does the paper contribute?

Answer: Three contributions, stated at the end of Section 1.

  1. A multiscale latent state whose coarser levels act only through the dynamics. All three levels advance jointly in latent space and the field is read from Fine alone, so Middle and Coarse hold what helps future evolution rather than what reconstructs the present, and their role can be tested with encoder and readout fixed.
  2. Long-horizon fidelity, boundedness, and speed. Over steps 13–30, Test VRMSE is 0.508 (shear flow) and 0.848 (TRL2D), below the four published baselines (shear flow: v1 Test). Against Walrus-architecture predictors of similar size, EvoState has less than half the shear-flow error at step 64 (0.835 vs 2.060) and diverges in 1 of 112 rollouts by step 512, against 63; it has lower TRL2D error from step 6 on and takes about half the time per step (8.1 vs 15.6 ms; 6.7 vs 16.6 ms). Beyond the decorrelation time it keeps the perturbation amplitude near the truth, whereas the baseline inflates it on shear flow and damps it on TRL2D. At step 64 on shear flow, the perturbation correlation (trajectory agreement) is 0.82 vs 0.33; on TRL2D both correlations are near 0 by then, and only amplitude differs (Sections 5.1 to 5.3).
  3. Distinct roles of the levels. Carry gives the lowest long-horizon error: with everything else fixed (2-epoch variants), per-step recompute raises step-32 and step-64 shear-flow error by 27.4% and 20.9%, and Fine only by 29.8% and 23.7%, with all intervals excluding zero (Fig. 6, Table 18). Replacing the carried coarser levels at inference with recomputed ones raises step-64 error by 113%, even though the recomputed states are closer to the true encoding (Fig. 20). A change in Coarse grows about 17-fold by step 32, while one in Fine fades (Fig. 21; Section 5.4).

What this shows: the first two contributions say what EvoState is and where it improves; the third shows that the levels do work. The comparison with Walrus-architecture predictors changes state structure, rollout space, and objective together, so we do not attribute that gap to the levels alone; the levels are tested by within-model comparisons.

a/: Can the paper be clearer?

Answer: Yes. The revision rewrites the abstract and introduction and unifies the terminology.

We improved the paper's organization and terminology:

  • The abstract and introduction move from why to split by scale, to how to obtain the levels, to how to organize them.
  • Section 4 separates physical systems, training and baselines, and evaluation.
  • Results have four parts (Sections 5.1 to 5.4): accuracy and cost per step, what pointwise error misses, beyond the training conditions, and roles of the levels.
  • τ and the structure metrics are defined at first use, and each concept has one name.

If any part is still unclear, please point it out and we will be glad to clarify further.

AuthorsOpenReview ↗

Other datasets, Walrus baselines, and generalization

b/: Other datasets with a different scale dependence?

Answer: Yes. The revision adds TRL2D, where EvoState has lower error than the published baselines from step 6 on.

TRL2D, a radiatively cooled turbulent mixing layer from The Well, decorrelates within 3 to 5 frames, against 9 to 49.5 for shear flow, so its scale dependence differs markedly. The two systems share architecture and loss weights, and Test was evaluated once. EvoState (mean of two independent training runs) reaches 0.448 and 0.848 VRMSE over steps 6–12 and 13–30, against 0.54 and 1.01 for CNextU-net, the best published baseline; at step 16 (about 5τ), predicted density keeps 0.94 of the true amplitude (Table 11, Appendix C.2).

c/: How is the Walrus-style Transformer built?

Answer: With Walrus's official code and one-step objective; for a fair comparison the revision adds versions of comparable size. Appendix B.5 gives the construction.

All Walrus-architecture predictors use Walrus's space–time factorized attention and predict the next-step increment. The three 140M models of Figure 1 (hidden width 768, token grids from 16×16 to 64×64) only motivate the question. Walrus-SF-12M and Walrus-TRL-12M match EvoState in parameters (12.0M vs 11.2M) and training windows and get the same four input frames at evaluation.

Results: trained on a one-step objective, the Walrus-architecture predictors are more accurate over the first steps, which is what that objective optimizes. Later in the rollout EvoState is more accurate: at step 64 on shear flow its error is less than half (0.835 vs 2.060), with divergence 0/112 vs 4/112, and over steps 13–30 on TRL2D its error is 23% lower (0.848 vs 1.100).

d/: How well does EvoState generalize?

Answer: It holds up on another system, on cooling times held out of training, on rollouts beyond the training length, and with degraded inputs.

  • Another system. One architecture and one set of loss weights serve two systems with very different decorrelation times (see b/).
  • Held-out cooling times. On TRL2D, we removed every trajectory of one cooling time from transition-model training; the encoder and readout saw all cooling times, so this tests the dynamics. EvoState's error on the held-out cooling time stays within 10% of the all-condition model (+7.8% and −5.7%). Retrained the same way, the Walrus-architecture predictor has higher error at 0.32 and is close at 3.16 (Section 5.3).
  • Rollouts beyond the training length. On shear flow, rolled out to 512 steps, 2.8 times EvoState's longest training rollout (184 steps), 1 of 112 EvoState rollouts diverges numerically, against 63 for Walrus-SF-12M trained on the same number of windows, 35 of them after step 184 (Section 5.3).
  • Degraded inputs. On shear flow, with noise, missing data, or outliers in the four input frames, EvoState's error grows less than Walrus-SF-12M's in all eight settings, for example 1.73× vs 8.16× at 10% noise (Section 5.3).
AuthorsOpenReview ↗

Response to Reviewer RzBV: an extrapolated operating condition and a larger Walrus-architecture predictor

Since our response, we have added two results that bear on your question about generalization (d) and on your remark about foundation models, for which the closest controlled test we can run is a much larger Walrus-architecture predictor trained on the same data. As in the revised paper, we report each comparison in both pointwise error and field structure. The perturbation correlation r measures whether the predicted vortices sit where the true ones are, the perturbation amplitude ratio a measures whether their strength is right, and the field maps show their shape (Section 4).

An extrapolated operating condition (d). We removed all shear-flow trajectories at the highest Reynolds number, Re = 5×10⁵, from transition-model training, retrained EvoState's transition model and the whole similar-size Walrus-SF-12M, and evaluated Test once. The outcome follows the same pattern as with all conditions in training. Over steps 13–30 the two models have similar mean errors (0.542 vs 0.528), although EvoState already places the vortices more accurately (r = 0.868 vs 0.792). After that, EvoState leads on both measures: over steps 31–64 its error is lower on 24 of the 28 trajectories, and at step 64 its error is 0.831 against 1.746 and its correlation 0.79 against 0.26. The fields show the same difference. EvoState rolls the tracer up into billows at the true vortex positions, whereas Walrus-SF-12M remains at flattened lobes that never fully roll up (Fig. 4c). Neither model diverges, and EvoState's tracer error stays within 3% of that of its counterpart trained on all conditions.

A larger Walrus-architecture predictor. The 140M models in the submission had been trained on at most 24,576 windows. In the revision, Walrus-SF-140M, about 12.5 times the size of EvoState, is trained on the same number of windows as EvoState (1,084,160). Even against this larger model, EvoState keeps its advantage once the flow decorrelates. Walrus-SF-140M has the lower four-channel mean error. From steps 13–30 onward, however, EvoState has the lower error in most windows (78 of 112 over steps 31–64), and at step 64 its perturbation correlation and amplitude ratio are closer to the truth (0.820 and 0.886, against 0.550 and 0.675). In the Test example of Fig. 3a (Fig. 12), Walrus-SF-140M stretches the tracer vortices into filaments, while EvoState matches their number and positions; in a Valid pressure example (Fig. 11), EvoState keeps the four low-pressure vortex cores, while both Walrus-architecture predictors smooth them out. The gap in mean error comes from pressure, mainly from 21 windows in which the true pressure is nearly uniform, so that VRMSE divides by a near-zero variance. Without these windows, EvoState has the lower four-channel mean over steps 31–64 (0.340 vs 0.513). EvoState also needs only about 1/32 of the time per step on the same GPU (7.2 vs 229 ms).

The revised PDF contains both results, together with the data-sharing analysis and the clarified contributions (Sections 1, 4, and 5; Appendices A.1, C.4, and C.9).

We hope these results address your questions on generalization and on larger models. We would be glad to answer any remaining question before the discussion closes.

Reviewer_azQsOpenReview ↗
Rating
3
Confidence
2
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper investigates which latent states should persist across autoregressive steps when predicting physical dynamics from a short observation history. Here we have an example in fluid dynamics, this can also extend to other particular examples. It introduces EvoState, which separates hierarchical representation learning, latent evolution, and physical readout. A hierarchical encoder produces Fine, Middle, and Coarse representations; a transition model jointly advances these representations from a four-state history; and a fixed, separately trained readout reconstructs physical fields from Fine alone. Middle and Coarse are maintained as evolving states rather than being constrained to deterministic transformations of the predicted Fine state.

The authors evaluate EvoState on The Well’s shear-flow task. A controlled comparison examines three formulations: carrying all three predicted levels, recomputing Middle and Coarse from Fine, and omitting coarse-state feedback. The formulations share architecture, initialization, data order, and training schedule, although the latter two also change the supervision path. A separate inference-time intervention replaces the carried coarse states in the trained full model with states recomputed from Fine.

Under the matched two-epoch, single-seed ablation recipe, recomputing or omitting coarse states increases mean paired per-window NRMSE at the 64-step horizon by 20.9% and 23.7%, respectively, relative to carrying all three levels. The paper also reports comparisons with Walrus-SF models, Persistence, and published benchmarks. In the inference-time intervention, recomputed coarse states are closer to true-frame encodings but yield worse physical predictions, indicating that same-frame latent accuracy alone is insufficient to assess state utility for a trained transition.

The findings provide task- and recipe-specific evidence favoring persistent hierarchical states, while leaving the respective contributions of state feedback, supervision pathways, and adaptation to the carried-state distribution incompletely resolved.

Critical strengths

The paper addresses a focused and worthwhile research question. For long-horizon autoregressive prediction, a model must not only represent the current physical field accurately but also preserve useful information through repeated updates. Although the Middle and Coarse representations can be computed from Fine at encoding time, whether they should be maintained as persistent states during rollout remains worth investigating. Answering this question can inform state design for latent dynamics models.

The experimental design is reasonably well controlled. The authors explicitly compare carrying, recomputing, and omitting coarse-state feedback, while holding the encoder and readout fixed to evaluate alternative latent-evolution formulations. These comparisons provide insight into the design choices themselves, beyond demonstrating that the complete system outperforms a particular baseline.

Critical weaknesses

The evaluation is affected by overlap between the training and test data. Section 4 and Appendix A.1 explicitly acknowledge that some test trajectories are identical to training trajectories, but the paper does not quantify their number, proportion, or distribution across physical conditions.

Consequently, it is difficult to determine how strongly the reported results support generalization to unseen trajectories or how sensitive the reported performance advantages are to duplicated samples. This limits the generalization evidence. Retaining the official splits facilitates comparison with published benchmarks, but does not replace an independent evaluation on non-overlapping trajectories.

Questions for authors
  1. Section 4 and Appendix A.1 note that some test trajectories also appear in the training set. How many trajectories overlap between Train–Valid and Train–Test, respectively? If a non-overlapping subset exists, could you report the main results on it to assess whether the gains depend on duplicated samples?

  2. In the recomputed- and absent-coarse variants, the coarse losses are computed from states reconstructed from Fine, so both the feedback rule and the supervision pathway change. How could their contributions be separated? For example, does carrying coarse states still help when the supervision is held consistent and only the feedback rule changes?

2 comments
AuthorsOpenReview ↗

Response to Reviewer azQs : Train–test overlap and the role of carry

Thank you for the careful review; we have taken your suggestions on board. In the revision we retrain and evaluate shear flow on the official corrected v2 split, add a second physical system, TRL2D (a radiatively cooled turbulent mixing layer), and compare with Walrus-architecture predictors of comparable size trained on the same number of windows. We also test rollouts beyond the training length, degraded inputs, and held-out operating conditions, and release a first version of the code and weights. We answer your two questions below.

W1, Q1: Train–test overlap. Do the results hold on unseen trajectories?

Answer: The overlap does not drive the result. Removing the copies changes the long-horizon error by only 8.5%, and EvoState retrained on the copy-free v2 split has lower error from step 6 on. Conditions absent from training are tested on TRL2D (second comment).

How large the overlap is. Our submission flagged copies in v1 (Section 4, Appendix A.1) but did not count them. In v1, 88 of 112 Valid and 89 of 112 Test trajectories exactly match Train trajectories; by Reynolds number (10⁴, 5×10⁴, 10⁵, 5×10⁵), the Test copies number 24, 20, 22, and 23 of 28. The maintainers released corrected splits on October 19, 2026 and advise against comparing v1 scores.

Without the copies. On the 20 Test trajectories that have no copy anywhere, the submitted model reaches 0.713 VRMSE over steps 13–30, against 0.657 on all 112 (an 8.5% difference), and 0.336 against 0.349 over steps 6–12.

Retraining on v2. No v2 Valid or Test trajectory copies a Train trajectory. Four-channel mean VRMSE; each v2 endpoint was evaluated once on the official Test set:

Forecast stepEvoState v1 (7 ep)CNextU-net v1EvoState v2 (7 ep)EvoState v2 (10 ep)
10.0420.80800.0900.092
6–120.3492.330.2910.261
13–300.657>100.5660.508
641.083—0.9120.835

At 7 epochs, error at every step from 6 on is lower on v2 than on v1. The cosine learning-rate schedule spans 10 epochs; the submitted model stopped at 7, and completing the schedule lowers long-horizon error further. The paper reports the 10-epoch endpoint (Section 5.1); the 7-epoch column allows comparison with the submission.

Scope of the v2 Test. Each v2 Test trajectory shares its initial velocity with a Train trajectory at another Schmidt number (Appendix A.1), so the shear-flow Test measures prediction for the same family of flows at new Schmidt numbers (tracer VRMSE 0.259 over steps 13–30, Appendix C.1). Conditions absent from training are tested on TRL2D.

What this resolves: on the copy-free split, the result holds.

Q2: With supervision held fixed, does carrying the coarser levels still help?

Answer: Yes. When the carried levels are supervised, as in EvoState, carry has the lowest error of all five TRL2D variants at steps 8 and 16 (Table 24, Appendix D.8).

Carry in the paper. With everything else fixed (2-epoch variants, v1 split), per-step recompute raises error over carry by 27.4% and 20.9% at steps 32 and 64, and Fine only by 29.8% and 23.7%; all four intervals exclude zero (Fig. 6, Table 18). Replacing the written-back coarser levels at inference with recomputed ones raises step-64 error by 113%, even though the recomputed states are closer to the true encoding (Fig. 20). These shear-flow variants also change where the coarser-level losses act (Section 4, Appendix D.1). We therefore ran the design you proposed on the lighter TRL2D, varying write-back and coarser-level supervision separately. Within a row only the written-back states differ, which also changes the gradient path into Fine (four-channel mean NRMSE at step 8 / step 16, 24 Valid windows; Table 24, Appendix D.8):

Coarser-level lossCarryPer-step recomputeFine only
Yes (EvoState)0.228 / 0.3260.242 / 0.347—
No0.262 / 0.4480.252 / 0.3550.247 / 0.371

What it means. EvoState supervises the levels it carries, and in that setting carry is the best of the five. The rows without the coarser-level loss describe a different training method, in which the unsupervised carried states drift from the encoder's coordinates.

What this resolves: with supervision held fixed as in EvoState, carrying helps; on TRL2D, which decorrelates within 3–5 frames, the margin is clearest at step 8.

AuthorsOpenReview ↗

Generalization beyond the original setting

Additional results: Does EvoState generalize beyond the original setting?

Answer: Yes: on a second physical system, on cooling times held out of training, on rollouts beyond the training length, and with degraded inputs.

A second physical system (TRL2D). TRL2D is a different kind of dynamics in The Well, and its Test trajectories are independent simulations not used in training. Architecture and loss weights match shear flow, settings were chosen on Valid, and Test was evaluated once. On its nine Test trajectories, EvoState (mean of two independent training runs) reaches 0.448 and 0.848 VRMSE over steps 6–12 and 13–30, below CNextU-net, the best published baseline (0.54 and 1.01), with no numerical divergence (Section 5.1).

Held-out cooling times (TRL2D). We removed every trajectory of one cooling time from transition-model training (t_cool = 0.32, inside the range, and 3.16, the upper end) and retrained. The encoder and readout saw all cooling times, so this tests how the dynamics generalize. On the held-out cooling time, EvoState stays within 10% of the all-condition model (+7.8% and −5.7%). Retrained the same way, the Walrus-architecture predictor has higher error at 0.32 (VRMSE 0.680 vs 0.572 over steps 1–16, with EvoState lower on 9 of 10 trajectories) and is close at 3.16 (0.575 vs 0.565, 6 of 10) (Section 5.3, Appendix C.7).

Beyond the training rollouts, and degraded inputs (shear flow). Rolled out to 512 steps, 2.8 times EvoState's longest training rollout (184 steps), 1 of 112 EvoState rollouts diverges numerically, against 63 for Walrus-SF-12M trained on the same number of windows. Of those 63, 35 diverge after step 184, where EvoState has no new divergence (criterion in Appendix A.5). With noise, missing data, or outliers in the four input frames, EvoState's error over steps 13–30 grows less than Walrus-SF-12M's in all eight settings, for example 1.73× vs 8.16× at 10% noise (Section 5.3, Appendices C.5 and C.6).

Comments on the paper

1 comment
AuthorsOpenReview ↗

Summary of the revision and of results added during the discussion

We thank all four reviewers for their careful reviews, which have substantially improved the paper. Below we summarize what the revised PDF now contains, so that the changes can be read in one place; the replies in each thread give the details. Substantive changes are marked in blue.

What the paper shows. EvoState divides the state passed between prediction steps into three latent levels from a frozen single-frame encoder and evolves all three jointly. The revision tests two consequences of this design: it should pay off once the flow begins to decorrelate, and the coarser levels should act as evolving state rather than as a function of the finest level.

ConcernWhat the revision addsWhere
One dataset onlyA second system, TRL2D, with very different decorrelation times, in the main comparison and the write-back controlSec. 4, 5
Train–test overlapShear-flow main results on the revised official v2 split (Fig. 1, the published shear-flow baselines, and the shear-flow write-back controls remain on v1); the remaining sharing of initial velocity fields is quantified and its consequence statedSec. 4, App. A.1
Conditions absent from trainingAn interpolated (TRL2D, cooling time 0.32) and an extrapolated operating condition (shear flow, Re = 5×10⁵), each held out from transition-model trainingSec. 5.3, App. C.8, C.9
Baseline size and training exposureWalrus-architecture predictors of similar size, and Walrus-SF-140M trained on the same number of windows as EvoStateTable 2, Sec. 5.1, App. C.3, C.4
Feedback and supervision confoundedA control on TRL2D that varies the write-back rule and the coarser-level losses separatelySec. 5.4, App. D.8
RobustnessRollouts to step 512 and eight degraded-input settingsSec. 5.3, App. C.6, C.7
Code and paper differCode, configurations, and weights of every model we trained and report in the paper, with the evaluation harnessAnonymous repository
Training variability and evaluation uncertaintyTwo independent TRL2D training runs; bootstrap intervals for the write-back controlsTable 10, App. D.2, D.8
Clarity and positioningContributions restated, terms defined at first use, positioning relative to HEAPSec. 1, 2

Main results. We compare along pointwise error, field structure, numerical stability, and cost per step (Section 4).

  • Against Walrus-architecture predictors of similar size, EvoState trails over the first steps and leads once the flow decorrelates, on both systems. At shear-flow step 64 its error is less than half (0.835 vs 2.060) and its perturbation correlation 0.82 vs 0.33; rolled out to step 512, it diverges in 1 of 112 windows against 63; and each step runs 1.9–2.5 times as fast.
  • The advantage holds at both held-out operating conditions. At Re = 5×10⁵, EvoState's four-channel error over steps 31–64 is 35% lower on Test, on 24 of 28 trajectories.
  • Against Walrus-SF-140M, about 12.5 times larger, EvoState has the higher mean error; over steps 31–64 this gap lies in 21 windows with nearly uniform pressure, without which its mean is lower (0.340 vs 0.513). From steps 13–30 on, it has the lower error in most windows and a more faithful structure, at about 1/32 of the time per step.
  • Within EvoState, on shear-flow Valid, replacing carry with per-step recompute, or keeping only Fine, raises the paired step-64 error by 20.9% and 23.7%. The TRL2D control shows that this advantage requires direct losses on the coarser levels.

We hope the revision addresses the reviewers' main concerns. We would be grateful for any further comments before the discussion closes and will answer them promptly.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.