acceptodds
Under review as a conference paper at ICLR 2027

GalerkinFlow: Flow Matching in Function Space via Galerkin Projection

Abstract

Existing time-series generative models evolve every sampled value, so the generative state grows with window length even when the underlying signal is compact. Functional approaches lift this to infinite-dimensional spaces but still discretize at inference, leaving the state tied to the sampling grid. We introduce GalerkinFlow, which sidesteps both limitations by shifting generation entirely into a low-dimensional spline coefficient space. Each observed window is projected onto a fixed cubic B-spline basis via ridge fitting, a Transformer learns the joint coefficient distribution through standard flow matching, and a fixed linear synthesis map decodes samples on any prescribed grid. Because synthesis is an isometry in the spline Gram metric, the squared functional Wasserstein error decomposes exactly into a projection floor set by the basis and a coefficient-transport term that training can reduce — providing an explicit error budget absent from prior work. A further bound accounts for fitting coefficients from finite, possibly incomplete, observations. GalerkinFlow achieves the lowest Context-FID on all six regular benchmarks, outperforms \smf on irregular-to-irregular generation at every tested nonzero drop rate, and trains 2.5–4.6 faster across the regular benchmarks.

Primary area:
generative models
Keywords:
Generative Model, Flow Matching, Machine Learning

Reviews

Among:
Shape:
1234this paper, Top 30%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.67 over 3 reviews, above 70% of the others.
Reviewer_x2ZFOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

They propose a time-series generator that does flow matching on the coefficients of a fixed cubic B-spline basis instead of on the sampled values (GalerkinFlow). The coefficients are fitted using ridge regression objective. They use a DiT-style Transformer with one token per basis coefficient and learn the flow with standard rectified flow; for doing the decoding they use a fixed linear map to generate new coefficient matrices. For incomplete data, missing entries are linearly interpolated before fitting, and the loss is only applied on observations after decoding. They also show that because the decoder is linear the Wasserstein error divides into a spline error and a coefficient learning error. Their results show the method has the best Context-FID on all six regular benchmarksnd they argue the their model processes significantly less tokens than a comparable model that is based on sample value generation.

Critical strengths

1- The idea of using a fixed linear encoder or decoder around a standard flow-matching transformer looks simple and practical . It is well motivated in the paper with a clean error decomposition, so it should be easy to reproduce and train. Also, the decomposition together with the synthetic study gives a useful rule to check before training and thinking about reducing token reduction for horizon time series is an exciting open question to be investigated.

2- They have competitive results on all benchmarks, with arguably context FID gains compared to SMF and Diffusion-TS. If these results hold with a proper seed variance and statistical significance, it is an interesting finding although in current state is overstated by the paper claims in the abstract and also see Weakness .

Critical weaknesses

1- They made a strong SOTA claim, but the results doesnt statistically significant to support them. Most margins are within the reported uncertainty of the baselines. In Table 1, their method is clearly outside the error bound of all baselines only for FID on ETTh. On MuJoCo and Energy it is better than SMF and Diffusion-TS but overlaps with FFM-OT (here also +- values are much larger than its means, which is also strange). Everywhere else it overlaps with at least one baseline. Also, GalerkinFlow’s uncertainty doesn’t include generator variance, which makes the bounds less reliable. I can see similar patterns in Tables 2 and 3. This needs a discussion or narrowing down the claims accordingly.

2- in the motivation section the authors claim token reduction when K << N and a per-step cost that doesn’t depend on the grid. However on six of the benchmarks here K = 32 > N = 24, so there is no reduction. Therefore, how the 2.5–4.6× speedup over SMF? is it probably coming from the model size or architecture differences and not the spline usage.

3- The abstract and the theory talk about the method in function space, but the generated samples are never evaluated as functions. All metrics are on the training grid, and there is no off-grid or resolution-transfer experiment.

Questions for authors

1- +- values for GalerkinFlow are 95% CI? if so it shows the evaluator variance and not generator variance. Can you report the results in Tables 1- 3 with mean +- std over independently trained generators (with different training seeds) while you keep a single uncertainty rule across all of them?

2- In Table 1, GalerkinFlow’s advantage falls outside the reported uncertainty only for FID on ETTh, MuJoCo, and Energy. In other places its intervals overlap those of at least one baseline. Also similarly in Table 2 and 3. Given this, on which dataset–metric you consider the improvement statistically significant to claim SOTA?

3- the paper claimed token reduction when K<<N, but on all six regular benchmarks K = 32 and N = 24 which shows the experiments aren't selected carefully selected. As I see here the model processes more tokens than a raw-value model then what exactly explains the 2.5–4.6× training speedup over SMF in Table 10? Also can you report parameter counts and flops too?

4- The abstract and Section 4 you frame the method in the function space but all metrics are computed on the training grid and no offgrid or resolution transfer evaluation is being done here, can you provide such an experiment?

9 comments
AuthorsOpenReview ↗

Error Bars

We want to express our sincere thankness for reviewer's valuable opinions and problems for our work. We will answer each problem one by on in the following.

1. Error bars and variation across trained generators

Our original Context-FID uncertainty convention followed SMF’s released regular-benchmark workflow. Its evaluation code repeats metric evaluation on a fixed generated dataset, and its reporting function calculates 95% Student-t confidence-interval half-widths. Our Appendix C.3 states the same convention. These intervals describe evaluator variability.

We agree that including variation from generator training provides a more complete assessment, so we provide the required table in the following:

DatasetMethodContext-FID ↓Correlation ↓Discriminative ↓Predictive ↓
StocksGF0.018 ± 0.0040.014 ± 0.0030.018 ± 0.0020.037 ± 0.001
OFM0.028 ± 0.0020.016 ± 0.0010.020 ± 0.0040.037 ± 0.001
FMF0.516 ± 0.0700.010 ± 0.0020.117 ± 0.0040.039 ± 0.001
SMF0.012 ± 0.0040.009 ± 0.0050.029 ± 0.0270.037 ± 0.001
ETTh1GF0.010 ± 0.0010.024 ± 0.0010.008 ± 0.0040.121 ± 0.001
OFM0.025 ± 0.0020.026 ± 0.0030.012 ± 0.0020.121 ± 0.001
FMF1.097 ± 0.0700.131 ± 0.0090.262 ± 0.0090.133 ± 0.001
SMF0.057 ± 0.0070.046 ± 0.0030.020 ± 0.0040.122 ± 0.001
EnergyGF0.048 ± 0.0010.514 ± 0.0650.172 ± 0.0030.259 ± 0.001
OFM0.055 ± 0.0190.578 ± 0.0450.115 ± 0.0770.253 ± 0.001
FMF0.603 ± 0.2361.054 ± 0.1040.332 ± 0.0170.254 ± 0.001
SMF0.052 ± 0.0030.748 ± 0.0270.165 ± 0.0220.251 ± 0.001
fMRIGF0.106 ± 0.0211.028 ± 0.0300.104 ± 0.0130.099 ± 0.001
OFM0.115 ± 0.0030.917 ± 0.0200.053 ± 0.0100.099 ± 0.001
FMF0.114 ± 0.0051.761 ± 0.1370.150 ± 0.0490.099 ± 0.001
SMF0.112 ± 0.0020.747 ± 0.0210.129 ± 0.0450.100 ± 0.001
MuJoCoGF0.010 ± 0.0010.172 ± 0.0080.007 ± 0.0010.008 ± <0.001
OFM0.017 ± 0.0020.194 ± 0.0080.007 ± 0.0010.009 ± 0.001
FMF0.015 ± 0.0010.197 ± 0.0060.007 ± 0.0020.008 ± 0.001
SMF0.022 ± 0.0020.186 ± 0.0140.008 ± 0.0030.008 ± 0.001
SinesGF0.002 ± 0.0010.016 ± 0.0010.006 ± 0.0020.093 ± 0.001
OFM0.002 ± 0.0010.016 ± 0.0020.005 ± 0.0010.093 ± 0.001
FMF0.009 ± 0.0010.016 ± 0.0010.021 ± 0.0040.094 ± 0.001
SMF0.005 ± 0.0010.024 ± 0.0040.010 ± 0.0010.093 ± 0.001
AuthorsOpenReview ↗

Statistical significance

2. Statistical significance and the scope of the performance claim GalerkinFlow’s strongest result in the submitted Table 1 is its consistently low mean Context-FID across datasets. It has the lowest reported mean on all six regular benchmarks. The differences from SMF are particularly large on ETTh1, MuJoCo and Energy, as the following comparison shows.

DatasetGF Context-FID ↓SMF Context-FID ↓Diffusion-TS Context-FID ↓
Stocks0.0050.0080.169
ETTh10.0140.0580.126
Energy0.0290.0510.113
fMRI0.1080.1160.118
MuJoCo0.0080.0180.015
Sines0.0030.0040.013

These are reported means from the submitted Table 1, in the original metric units. They summarize the observed differences and are not significance-test results. The original intervals measure evaluator variability and do not establish statistical superiority across independently trained generators. We will therefore replace the broad SOTA wording with the specific dataset and metric findings supported by the evidence.

The close predictive scores also deserve a task-specific interpretation. This metric measures how well a forecaster trained on generated sequences predicts real observations. On Stocks, GF, SMF and Diffusion-TS all have a reported predictive score of 0.037, while their mean Context-FIDs are 0.005, 0.008 and 0.169. The predictive evaluator gives similar scores at the displayed precision, while Context-FID separates their reported means. Similar predictive scores can therefore coexist with differences in measured distributional fit. We will describe predictive near ties as similar reported scores and discuss the differences measured by the other metrics.

The submitted Table 2 also reports better mean results than SMF on all three metrics for both long-horizon datasets. Table 3 contains both favorable means and close comparisons. For example, at 70% missingness in irregular-to-regular generation, GF and SMF score 0.016 and 0.015. We will describe this as a close comparison and retain the setting-specific conclusions.

Long-sequence computation provides a separate practical advantage. GalerkinFlow evaluates its velocity network on KK coefficient tokens, independently of the number of output positions. A controlled comparison with the same Transformer architecture measures the benefit when K=32K=32 and the output grid is much longer.

Output grid pointsCoefficient-network evaluation msRaw-grid network evaluation msSpeedup per network evaluationOne-time spline decoding ms
7282.14925.87912.045×0.136
7912.17829.63213.606×0.137

Both networks use width 96, four Transformer blocks, four heads, six channels and batches of 64 on one single GPU. Times are medians of 30 repetitions after ten warmup iterations, measured on synthetic inputs.

At 791 positions, the coefficient network takes 2.178 ms per evaluation compared with 29.632 ms for the raw-grid network. This reduces the cost of the operation repeated throughout sampling, while the final decoding takes 0.137 ms per batch. The experiment demonstrates the computational benefit of the fixed coefficient state as the output grid grows.

We will revise the performance claim to emphasize low reported Context-FID, competitive predictive scores and reduced network computation on long grids. These findings support the practical value of a fixed coefficient-space generator and complement the paper’s continuous representation and error analysis.

AuthorsOpenReview ↗

Explain the Speed Ups

3. Short-window speedup, parameter counts and FLOPs GalerkinFlow’s computational advantage comes from processing K coefficient tokens at each sampling step, independently of the number of output positions. This benefits long sequences when KK is much smaller than NN. You are correct that it cannot explain the short-window result with K=32>N=24K=32>N=24. We will separate the timing of the original implementations from the benefit demonstrated by the controlled experiment below.

To isolate that benefit, we compare two versions of the same Transformer. One processes 32 spline coefficients per channel, and the other processes the values at all NN grid points. Both use width 96, four Transformer blocks, four attention heads and feed-forward width 256. We measure them on one GPU with six channels and batches of 64.

Cost with the same Transformer architecture

Timings are in milliseconds per batch and report the median of 30 repetitions after ten warmup iterations. A training step includes the forward pass, backward pass and optimizer update. MFLOPs are approximate forward matrix-product operations per sample, counting two operations per multiply-add. The final column measures the separate spline decoding operation.

RepresentationGrid size NNNetwork tokensParametersMFLOPs per sampleForward msTraining-step msDecode ms
Spline coefficients2432518,95023.9982.16814.0890.174
Grid values2424518,18217.7872.15713.976Not needed
Spline coefficients9632518,95023.9982.15914.1020.135
Grid values9696525,09480.7692.42614.066Not needed
Spline coefficients19232518,95023.9982.15714.0710.137
Grid values192192534,310189.5184.13014.118Not needed
Spline coefficients38432518,95023.9982.14714.0380.137
Grid values384384552,742491.9509.52626.840Not needed
Spline coefficients72832518,95023.9982.14914.0690.136
Grid values728728585,7661317.02225.87971.536Not needed
Spline coefficients79132518,95023.9982.17814.1690.137
Grid values791791591,8141507.51029.63281.622Not needed

The Transformer blocks have the same architecture in both versions. Parameter counts differ because the learned positional embeddings contain one vector for each network token. The FLOP estimates include the linear layers and attention matrix products. Normalization, softmax, nonlinear functions and spline decoding are outside this estimate.

The benefit becomes clear as NN grows. At N=791N=791, the coefficient model requires 2.178 ms for a forward pass, compared with 29.632 ms for the model operating on grid values. Training steps take 14.169 and 81.622 ms, respectively. These correspond to approximately 13.6 times faster forward passes and 5.8 times faster training steps in this controlled benchmark. The coefficient model's network cost stays nearly constant because it continues to process 32 tokens.

Generator parameter counts in the regular comparison

In the following, we record the number of parameters of each model. FA denotes Functional Attention used within GF's velocity network.

DatasetGFOFM adaptedFMF adaptedGF + FA directGF + FA matchedSMF storage-adapted
Stocks518,950419,5261,657,478433,150518,842356,800
ETTh1519,1431,657,6073,714,887433,343519,035356,864
Energy523,1963,770,7801,663,132437,396523,0881,086,432
fMRI527,4421,668,6581,668,786441,642527,3341,237,152
MuJoCo520,4943,766,2863,717,134434,694520,3861,233,696
Sines518,7573,714,0533,714,245432,957518,649356,736

We will revise the efficiency claim around these results. The fixed coefficient representation reduces repeated network computation when the output grid is much larger than the chosen basis.

Reviewer_pmVBOpenReview ↗
Rating
3(+1)
Confidence
3
Informativeness
2
Presentation
3
Soundness
3
Read review
Paper summary

This paper proposes GalerkinFlow, a time-series generative framework that performs conditional flow matching in a cubic B-spline coefficient space rather than directly modeling discrete values on dense time grids. By projecting each observed window onto a fixed KK-dimensional cubic B-spline basis via ridge regression, a Transformer learns the joint distribution of the resulting K×DK \times D coefficient matrices, which are decoded back to the target grid in a single linear step at the end of sampling. Leveraging the linearity and Gram-metric isometry of the spline decoder, the authors decompose the trajectory Wasserstein error into a basis approximation floor, a finite-sample fitting error, and a distribution learning error. Experiments on regular, long-horizon, and irregular time-series benchmarks show that GalerkinFlow achieves strong generation quality and faster training compared to existing functional and diffusion baselines.

Critical strengths
  1. Insightful Formulation in Coefficient Space: Moving flow matching from dense discretized time grids to a compact basis coefficient space is insightful, effectively decoupling the per-step network evaluation cost from the sequence length NN on long horizons.

  2. Natural and Elegant Spline Representation: Using cubic B-splines with ridge regression is a natural and well-motivated choice that yields a simple, elegant algorithm with a clean theoretical error decomposition.

  3. Clear Presentation: The paper is well-structured, clearly written, and easy to follow, with comprehensive ablations that connect empirical behaviors to the theoretical error budget.

Critical weaknesses
  1. Over-Smoothing of Sharp Transients and Tail Events: Cubic B-splines enforce global C2C^2 continuity across interior knots, inherently acting as a smoothing filter. However, the empirical evaluation primarily reports average distribution metrics (e.g., Context-FID and Correlation) and lacks dedicated evaluations on extreme values, tail distributions, or higher-order statistics (e.g., kurtosis), where smooth splines may struggle to capture sharp spikes in volatile data.

  2. Unjustified K>NK > N Setting and Null-Space Oscillations on Regular Benchmarks: On all six regular benchmarks, the window length is N=24N = 24, yet the default basis size is set to K=32>NK = 32 > N. In this regime, the model processes more tokens than the raw data (eliminating any inference compression benefit) and creates an under-determined linear system with an 8-dimensional null space. As shown in Appendix B.2, unconstrained null-space components can induce severe oscillations between the observed grid points. It is unclear why K≤24K \le 24 was not used as the default configuration for the main experiments.

  3. Heuristic Linear Interpolation for Missing Data: To handle incomplete sequences, the method relies on naive channel-wise linear interpolation before fitting spline coefficients. Under high missingness rates (e.g., 50% and 70% drop rates), simple linear filling introduces severe prior distortion and large initial fitting errors, which undermines the principled functional modeling motivation.

  4. Excessive NFE Budget in Main Comparisons: In Table 1, GalerkinFlow is evaluated using a very high sampling budget of 1,000 NFEs (500 midpoint steps), whereas the appendix ablations show that 40–50 NFEs already suffice. It is unclear whether the baseline methods in Table 1 were granted a comparable sampling budget, raising concerns about evaluation fairness.

  5. Missing Learned Latent-Space Flow Matching Baseline: While Table 4 compares cubic B-splines against other fixed analytical bases (Fourier, Legendre, and Haar), there is no comparison against flow matching in a learned latent space (e.g., an autoencoder-based Latent Flow Matching baseline). Thus, current experiments are insufficient to prove that a hand-crafted spline basis is superior to a data-driven learned latent representation.

  6. Missing Citations in Comparison Tables: In Tables 1–3, baseline methods are listed only by name without inline citations. Including the corresponding references directly in the tables would improve readability.

Questions for authors

Please refer to the weaknesses detailed above.

7 comments
AuthorsOpenReview ↗

Extreme Events

We give our sincere thanks to reviewer's detailed and useful reviews. We will address them in the following.

1. Sharp transients, tails and higher-order statistics

GalerkinFlow focuses on efficient generation in a fixed coefficient space, with an analysis that separates representation, fitting and distribution-learning errors. We do not claim that fixed cubic splines are the best representation for rare extreme events. Section 6 in our paper already acknowledges sharp transients as a limitation of uniform knot spacing. We thank the reviewer for prompting a more detailed evaluation of this limitation.

To answer the question, we added supplementary Stocks diagnostics for unusually large changes between consecutive time points. The first metric measures errors in the upper quantiles of absolute increments. The second measures the mean absolute error in Pearson increment kurtosis across channels. Both compare generated samples with the reference data, and lower values indicate closer agreement.

Stocks increment-tail diagnostics

RepresentationTail-quantile error in units of 10⁻³ ↓Pearson kurtosis error ↓
Spline K=24K=2492.311 ± 1.4185.714 ± 2.613
Spline K=32K=3287.066 ± 0.2185.450 ± 0.124
Nonlinear AE K=16K=1685.352 ± 1.3552.098 ± 0.318

Increasing the spline basis size from K=24K=24 to K=32K=32 lowers both mean errors. The nonlinear autoencoder nevertheless performs better on these diagnostics. Its tail-quantile error is about 2% lower than that of K=32K=32 splines, while its kurtosis error is substantially lower, at 2.098 compared with 5.450. This identifies a setting in which the tested learned representation better reproduces higher-order statistics.

Basis resolution and sharp-event fidelity

We also evaluated synthetic signals containing smooth oscillations, chirps, shocks and rare pulses. Their underlying trajectories are known, allowing evaluation between the training positions. Models are trained on 64 positions and are evaluated on a 505-position grid.

The following contain the results. Event-amplitude W1 compares detected pulse amplitudes. The chirp metric compares high-frequency energy fractions, and pulse q.999 error compares the 99.9th percentile of absolute pulse-channel values.

KEvent-amplitude W1 ↓Chirp high-frequency error ↓Pulse q.999 error ↓
160.349 ± 0.0240.291 ± 0.0040.239 ± 0.043
240.122 ± 0.0240.010 ± 0.0040.067 ± 0.026
320.075 ± 0.0100.004 ± 0.0030.064 ± 0.030
480.067 ± 0.0130.002 ± 0.0020.082 ± 0.015

With complete observations, increasing KK from 16 to 48 lowers mean event-amplitude error from 0.349 to 0.067 and chirp high-frequency error from 0.291 to 0.002. A larger basis therefore improves these aspects of generation in the tested configurations. However, the benefit is not uniform across tail statistics. Pulse q.999 error is lower at K=32K=32 than at K=48K=48, and substantial shock-moment discrepancies remain.

Remaining limitation on extreme shock increments

The following raw moments experiments make the remaining limitation explicit. These results use K32, complete observations and 50 network evaluations. Model values are mean ± sample standard deviation across five generators. Both reference and generated increments are measured on the same 505-position grid.

SettingCentered fourth moment in units of 10⁻⁶Pearson kurtosis
Reference data12,757.0481,092.225
Decoded loss with all observations1.529 ± 0.11326.484 ± 0.525
Coefficient MSE1.985 ± 0.04527.861 ± 0.298

The tested generators produce substantially smaller fourth moments and kurtosis than the reference. Thus, improvements in event amplitudes or frequency content do not ensure accurate extreme-increment statistics.

We will retain these findings and expand the discussion of sharp-event fidelity. The paper’s contribution remains the coefficient-space formulation, its computational structure and its error analysis, which does not guarantee accurate fourth moments. Future work can examine adaptive knot placement and improved learned continuous representations, assessing extreme-event fidelity alongside computational cost.

AuthorsOpenReview ↗

Basis Size Sweep

2. Basis size, identifiability and compression

The basis size controls the resolution of the continuous representation. It provides token compression when KK is smaller than the input sequence length. For the regular benchmarks with N=24,K=32N=24, K=32 provides no token compression. We will state this explicitly and present K=32K=32 as the submitted configuration, with KK selected through validation in practical applications.

You are correct about the undetermined coefficient directions. A 24-by-32 observation matrix has rank at most 24. At rank 24, eight directions per channel remain undetermined. Ridge regression selects a unique solution, but it cannot supply information missing from the observations. Choosing K≤24K≤24 removes this dimension mismatch, although stable fitting also requires a well-conditioned observation matrix.

We added comparisons of both generation quality and fitting stability. The complete Stocks sweep is shown below. Lower values are better.

Basis size KContext-FID ↓Correlation ↓Discriminative ↓Predictive ↓
160.010 ± 0.0010.008 ± 0.0040.011 ± 0.0030.037 ± 0.000
240.011 ± 0.0020.008 ± 0.0040.011 ± 0.0110.037 ± 0.000
320.009 ± 0.0020.005 ± 0.0030.012 ± 0.0070.037 ± 0.000
360.020 ± 0.0030.009 ± 0.0050.018 ± 0.0170.037 ± 0.000
400.012 ± 0.0010.012 ± 0.0060.011 ± 0.0120.037 ± 0.000
480.018 ± 0.0030.015 ± 0.0030.011 ± 0.0030.037 ± 0.000
960.019 ± 0.0030.017 ± 0.0050.044 ± 0.0310.037 ± 0.000

K=32K=32 has the lowest mean Context-FID, while K=16,40,48K=16,40,48 have the lowest mean discriminative score. Increasing KK beyond 32 gives no consistent improvement. These results support us to choose the K=32K=32 as the config.

We also test generation between observed positions on ETTh1. The models receive 24 observations from each window of 93 hourly measurements. After training, the same generated coefficients are decoded at all 93 positions. The 69 intermediate measurements are excluded from coefficient fitting and flow-training targets.

Training → evaluation pointsKContext-FID ↓Correlation ↓Discriminative ↓Predictive ↓
24 → 93243.605 ± 0.6080.429 ± 0.0050.469 ± 0.0010.124 ± 0.001
24 → 93320.136 ± 0.0060.062 ± 0.0020.309 ± 0.0070.115 ± 0.0002

K=32K=32 gives lower mean errors on all four fine-grid metrics, especially for the Context-FID score. These results show that even if in the cross-resolution experiments, the K=32K=32 is still a better choice. We will add these analysis and experiments into the PDF.

AuthorsOpenReview ↗

Interpolation Choice

3. Linear interpolation under high missingness

We added a direct comparison of linear filling and coefficient fitting from observed values alone. On Stocks, linear filling gives smaller errors inside the gaps and lower mean errors on all four generation metrics.

In specifics, we remove a contiguous block of 12 or 17 points from each 24-point window, giving 50% and 70.8% missingness while retaining both endpoints. One method fills the gap linearly before spline fitting. The other solves ridge regression using only observed values. Results are listed in the following table:

Missing pointsCoefficient fittingContext-FID ↓Correlation ↓Discriminative ↓Predictive in units of 10−310^{-3} ↓
12/24Linear fill then ridge0.011 ± 0.0070.006 ± 0.0010.057 ± 0.00137.039 ± 0.079
12/24Observed-only ridge0.589 ± 0.2080.064 ± 0.0480.469 ± 0.01973.633 ± 27.344
17/24Linear fill then ridge0.021 ± 0.0140.012 ± 0.0030.062 ± 0.03737.737 ± 0.725
17/24Observed-only ridge1.630 ± 0.2730.144 ± 0.0120.487 ± 0.005149.054 ± 20.534

The results above support linear filling as a useful preprocessing choice for the experiments.

Reviewer_vJV8OpenReview ↗
Rating
3(−1)
Confidence
2
Informativeness
3
Presentation
3
Soundness
3
Read review
Paper summary

This paper proposes a framework for multivariate time-series generation. The main approach consists of mapping discrete time-series windows into the coefficient space of a fixed cubic B-spline basis and performing conditional flow matching on the resulting coefficient matrices. Specifically, given an observed window, the authors estimate spline coefficients via ridge regression, train a Transformer velocity network and synthesize trajectories on the target grid via a linear decoding step. For incomplete sequences, missing entries are linearly interpolated prior to ridge fitting, and the velocity field is trained with a masked loss that only penalizes errors at observed grid entries. In Section 4, the authors equip the coefficient space with the spline Gram matrix and show that the continuous Wasserstein error splits into a spline approximation floor ​and a Gram-Wasserstein coefficient transport error. The authors evaluate GalerkinFlow on six regular benchmarks, two long-horizon datasets and missing-data benchmarks on Stocks, showing state-of-the-art Context-FID and faster training/sampling than Spectral Mean Flow.

Critical strengths

The main strength of this paper is the simplicity and practical utility of the core idea: to replace grid-level neural operators in functional flow matching with flow matching in a fixed, smooth cubic B-spline basis. The additional error analysis in Section 4 provides a nice framework for understanding the different error components. Moreover, the comparisons with other bases in Tables 4 and 5 are illustrative and compelling. The authors evaluate B-splines against Fourier, Legendre, Haar, and raw-grid representations on the same Transformer backbone (while matching the parameter count) and show that local smooth basis functions lead to a better-behaved coefficient distribution than global bases or raw grid values. The strong empirical performance across regular, long-horizon, and missing-data benchmarks as well as the training speedup over Spectral Mean Flow make this a nice contribution overall.

Critical weaknesses

While I like the proposed approach, I have three main concerns:

  1. Missing 2026 functional baselines and minor table inconsistencies:
  • Section 2 cites Functional Mean Flow in Hilbert Space (Li et al., CVPR 2026), which performs one-step and few-step functional generation, yet, as far as I can see, this method is omitted from all experimental comparisons (Tables 1, 2, 10, and 11), where GalerkinFlow is compared only against 2024–early 2025 functional models.

  • In Section 2, the Transformer-basis discussion stops at Cao (2021) and does not consider recent functional-basis attention work such as Functional Attention: From Pairwise Affinities to Functional Correspondences (Xiao et al., May 2026 / ICML 2026), which also maps discrete sequences into basis coefficients via regularized least squares to compute low-rank attention in function space and uses a learned adaptive basis.

  • If I'm not mistaken, the two Stocks basis-size sweeps in Table 9 and Table 18 report different Context-FID values for the same settings, especially at K=32K=32 (0.006 vs. 0.0032), K=40K=40 (0.019 vs. 0.0036), and K=48K=48 (0.030 vs. 0.0074), without explaining what changed between the two sweeps. This also suggests potential sensitivity to the basis size KK and optimization settings in practice.

  1. There might be a disconnect between the continuous Gram-matrix theory (Section 4) and the Euclidean algorithm (Section 3): The paper formulates the method as a Galerkin projection and relies on the continuous spline Gram matrix in Theorem 4.1 (because cubic B-splines are not orthonormal). However, unless I'm mistaken, the Gram matrix is never used anywhere in the actual algorithm. Specifically, ridge regression uses an isotropic Euclidean penalty, and so the prior is isotropic in Euclidean coefficient space rather than continuous function space. This would mean that the flow-matching loss uses the unweighted Frobenius norm rather than the Gram metric. Is this well-motivated?

  2. As far as I understand, for incomplete sequences, missing entries are linearly interpolated prior to ridge fitting. Even though the masked loss only penalizes errors at observed entries, the interpolated values still determine the fitted coefficients and the intermediate conditioning states which are used to train the velocity network. Therefore, when missing segments span non-linear or high-frequency variations where linear interpolation is poor, the masked objective can be biased (note that this is not the case for a standard basis-free masked loss).

Questions for authors
  1. Comparison with 2026 functional baselines (Functional Mean Flow and Functional Attention):
  • Why was Functional Mean Flow in Hilbert Space (Li et al., CVPR 2026), which is cited in Section 2, omitted from the empirical comparisons in Tables 1 and 11?
  • How does GalerkinFlow relate to Functional Attention: From Pairwise Affinities to Functional Correspondences (Xiao et al., May 2026 / ICML 2026), and would incorporating a regularized learned adaptive basis (as in Functional Attention) improve upon the fixed B-spline basis in Table 4?
  1. Choice of 32 basis functions for length-24 sequences and cross-resolution evaluation: since Table 6 shows 24 basis functions achieves four times lower continuous-time error than 32 basis functions and avoids an unsupervised null space under Equation 8, why was 32 chosen as the default for length-24 benchmarks? How does a model trained at length 24 (with 24 vs. 32 basis functions) perform when decoded on a finer evaluation grid?

  2. Discrepancy between Table 9 and Table 18 on Stocks: What experimental setting changed between the Stocks basis-size sweep in Table 9 and the sweep in Table 18?

  3. Since the cubic B-spline Gram matrix is fixed, and known analytically before training, why not adjust the basis coefficients using the matrix square root of the Gram matrix (or compute the flow-matching loss and prior covariance under the Gram metric) so that the algorithm matches the continuous function-space geometry of Theorem 4.1?

6 comments
AuthorsOpenReview ↗

Missing Baselines/Relevant Works

We sincerely thank the reviewer for helpful and constructive feedbacks and suggestions. We will answer questions one by one in the following.

1. Missing Functional Mean Flow comparison

We have now evaluated an FMF adaptation on all six regular datasets and both long-sequence datasets, including one-step and few-step sampling. The adaptation retains FMF’s mean-velocity objective, including its JVP and stop-gradient terms. But we need to point out that the Functional Mean Flow is designed for handling visual generation tasks like face generation and 3D generation, it does not focus on the time-series generation tasks.

The following table contains the results on six regular datasets.

DatasetMethodContext-FID ↓Correlation ↓Discriminative ↓Predictive ↓
StocksGF K320.009 ± 0.0020.005 ± 0.0030.012 ± 0.0070.037 ± 0.000
FMF adapted0.573 ± 0.1240.007 ± 0.0050.114 ± 0.0110.038 ± <0.001
ETTh1GF K320.014 ± 0.0010.027 ± 0.0070.015 ± 0.0060.121 ± 0.007
FMF adapted1.065 ± 0.0670.133 ± 0.0100.257 ± 0.0120.131 ± 0.006
EnergyGF K320.029 ± 0.0010.671 ± 0.0910.091 ± 0.0610.253 ± 0.000
FMF adapted0.484 ± 0.0711.015 ± 0.0880.321 ± 0.0060.256 ± 0.001
fMRIGF K320.108 ± 0.0040.763 ± 0.0240.091 ± 0.0350.100 ± 0.000
FMF adapted0.112 ± 0.0051.800 ± 0.0240.142 ± 0.0410.099 ± <0.001
MuJoCoGF K320.008 ± 0.0000.178 ± 0.0140.006 ± 0.0060.008 ± 0.001
FMF adapted0.013 ± 0.0010.197 ± 0.0250.011 ± 0.0080.008 ± 0.001
SinesGF K320.003 ± 0.0010.019 ± 0.0030.007 ± 0.0040.093 ± 0.000
FMF adapted0.009 ± <0.0010.015 ± 0.0050.019 ± 0.0130.094 ± <0.001

GalerkinFlow has lower mean Context-FID on all six datasets, while FMF performs better on Sines' Correlation metric. On other metrics, our GalerkinFlow has achieved overall better performances than the Functional Mean Flow.

For the long-sequence comparison, we list the corresponding results in the following table. Values are mean ± standard deviation across five trained generators.

DatasetMethodMarginal ↓Classification ↑Predictive ↓
FRED-MDGalerkinFlow0.0171.027 ± 0.1120.026 ± 0.006
FMF0.032 ± 0.0030.539 ± 0.0280.123 ± 0.050
NN5 DailyGalerkinFlow0.0070.911 ± 0.1040.418 ± 0.037
FMF0.034 ± 0.0020.036 ± 0.0111.230 ± 0.135

Classification follows the source benchmark’s higher-is-better BCE convention and note that it is not the regular accuracy metric. GalerkinFlow performs better on all three metrics FRED-MD means and NN5, compared with the Functional Mean Flow. From these two scenarios, we can see that our GalerkinFlow performs better than the Functional Mean Flow.

2. Missing Functional Attention discussion

Functional Attention is directly relevant and our Section 2 should discuss it. Its learned adaptive bases and functional correspondence operators extend the related work beyond the earlier Transformer-basis approaches we currently cited in the related work section.

The distinction between our model and theirs sits in where the basis is used. In specifics, Functional Attention learns bases within the attention operator. On ther other hand, our GalerkinFlow uses a fixed continuous synthesis basis to represent trajectories and learns their coefficient distribution. However, we need to point out that the Functional Attention provides an attention mechanism for operator learning but it does not specify a complete unconditional time-series generator. We will add this extra related work analysis into the PDF.

To further demonstrate the effectiveness of our model, we also tested the official Functional Attention core inside GalerkinFlow’s velocity network.

DatasetOriginal GFGF + Functional Attention
Stocks0.009 ± 0.0020.006 ± 0.001
ETTh10.014 ± 0.0010.018 ± 0.002
Energy0.029 ± 0.0010.050 ± 0.004
fMRI0.108 ± 0.0040.469 ± 0.023
MuJoCo0.008 ± 0.0000.012 ± 0.001
Sines0.003 ± 0.0010.002 ± 0.001

As we can see from the table, for most of the cases, Functional Attention will produce worse results. However, it reduces the FID metric score on Sines from 0.003 to less than 0.002. These results further demonstrate that our proposed framework is more suitable and effective for these time-series generation tasks. In the future, we will also explore some other replacements for current architecture.

AuthorsOpenReview ↗

Sweeps of K and Choices of K

3. Inconsistent Stocks basis-size sweeps

We acknowledge the inconsistency between Tables 9 and 18. We have conducted a new recorded sweep using seed 42, the SMF training and preprocessing recipe. The relevant entries are shown below. All four metrics are lower-is-better.

Basis size KContext-FID ↓Correlation ↓Discriminative ↓Predictive ↓
160.010 ± 0.0010.008 ± 0.0040.011 ± 0.0030.037 ± 0.000
240.011 ± 0.0020.008 ± 0.0040.011 ± 0.0110.037 ± 0.000
320.009 ± 0.0020.005 ± 0.0030.012 ± 0.0070.037 ± 0.000
360.020 ± 0.0030.009 ± 0.0050.018 ± 0.0170.037 ± 0.000
400.012 ± 0.0010.012 ± 0.0060.011 ± 0.0120.037 ± 0.000
480.018 ± 0.0030.015 ± 0.0030.011 ± 0.0030.037 ± 0.000
960.019 ± 0.0030.017 ± 0.0050.044 ± 0.0310.037 ± 0.000

From the table, we can observe that increasing K does not consistently improve generation: K=16K=16 gives a somewhat low observed mean Context-FID, while K=32K=32 gives the lowest mean Context-FID score. When we further increase the value of K, the Context-FID score will enlarge gradually, becoming worse and worse. We will revise Section 5.4 and Appendix B.2–B.3 accordingly.

These corrections refine the empirical interpretation without changing GalerkinFlow’s central formulation or theoretical analysis. The method learns a coefficient distribution in a fixed continuous synthesis space, and its error analysis remains applicable under the stated assumptions. As a result of this, the revised manuscript will therefore retain the methodological conclusion while reporting basis-size sensitivity explicitly.

4.Choice of K=32K=32 for length-24 sequences and cross-resolution evaluation

The submitted experimental results in our paper use K=32K=32 as a common configuration. We should have made clear that the theory does not prescribe this value. With 24 measurements per channel, the fitting matrix has rank at most 24. At rank 24, eight coefficient directions per channel remain undetermined by the observations. Ridge regression selects a unique regularized solution, but its values between observations can still be inaccurate. This configuration also processes more coefficient tokens than the 24 raw observations, so it provides no token compression on these short windows. Also note that the Table.6 in our paper only measures the reconstruction errors but not the regular adopted four metrics, we apologize for the confusions made there and we will replace the Table.6 with the new results below.

We tested whether this choice affects generation between observations by training K=24K=24 and K=32K=32 models on ETTh1 and evaluating them on a finer grid. Each window contains 93 hourly measurements. Only 24 values are used as coefficient-fitting and flow-training targets. Both models use the complete SMF ETTh1 training recipe. And after training, we sample coefficients from each generator and evaluate their splines at all 93 hourly positions. The generator and sampled coefficients stay fixed throughout this evaluation. Note that we do not fit the generated curves to the additional measurements. We compare the resulting windows with the recorded 93-point windows using all four official metrics. The result is listed in the following table.

Training → evaluation pointsKContext-FID ↓Correlation ↓Discriminative ↓Predictive ↓
24 → 93243.605 ± 0.6050.429 ± 0.0050.469 ± 0.0010.124 ± 0.001
24 → 93320.136 ± 0.0060.062 ± 0.0020.309 ± 0.0070.115 ± 0.0002

From the table, we can see that, at 93 points, K=32K=32 gives lower mean error on all four metrics. Its Context-FID is 0.136, compared with 3.605 for K=24K=24. Predictive scores are 0.115 and 0.124, respectively. These results show that in the cross-resolution cases, the K=32K=32 choice is a much better one compared with the K=24K=24 and lowering down the basis size may not automatically give better curves between observations. We will revise the PDF to present the K=32K=32 as an experimental configuration, including this extra cross-resolution testing experiment.

AuthorsOpenReview ↗

Gram based loss compared with the Euclidean based loss

5.Continuous Gram geometry versus the Euclidean algorithm

Actually, the Euclidean flow matching is consistent with the Gram based formulation. Concretely, with the prior and training path held fixed, Euclidean and Gram-weighted losses have the same ideal velocity predictor. Let UU denote the target velocity along a training path. At a given state aa and time tt, both losses are minimized by v∗(a,t)=E[U∣At=a,t]v^*(a,t)=\mathbb{E}[U\mid A_t=a,t], the average target velocity of paths passing through that state and time. The fixed positive-definite Gram matrix changes the penalty assigned to each error direction, but it does not change this conditional mean. Also, the continuous Gram matrix remains positive definite even when too few observed time points make coefficient fitting underdetermined, because the underlying spline functions are linearly independent.

Theoretically, there is also a direct bound. The Gram-weighted squared velocity error is at most the largest eigenvalue of GG times the Euclidean squared velocity error. Reducing the latter therefore tightens a bound on the corresponding function-space velocity error. This also explains why Euclidean training is consistent with the analysis. In a finite network, however, weighting the error directions can change what the model learns and how it is optimized. The comparison below tests their practical performance under the same training recipe.

DatasetLossContext-FID ↓Correlation ↓Discriminative ↓Predictive ↓
StocksEuclidean0.009 ± 0.0020.005 ± 0.0030.012 ± 0.0070.037 ± 0.000
Gram0.006 ± 0.0030.005 ± 0.0010.012 ± 0.0010.037 ± 0.000
ETTh1Euclidean0.014 ± 0.0010.027 ± 0.0070.015 ± 0.0060.121 ± 0.007
Gram0.010 ± 0.0010.024 ± 0.0030.009 ± 0.0020.121 ± 0.000
EnergyEuclidean0.029 ± 0.0010.671 ± 0.0910.091 ± 0.0610.253 ± 0.000
Gram0.032 ± 0.0010.685 ± 0.0520.286 ± 0.0060.259 ± 0.000
fMRIEuclidean0.108 ± 0.0040.763 ± 0.0240.091 ± 0.0350.100 ± 0.000
Gram0.128 ± 0.0010.868 ± 0.0100.286 ± 0.0040.101 ± 0.000
MuJoCoEuclidean0.008 ± 0.0000.178 ± 0.0140.006 ± 0.0060.008 ± 0.001
Gram0.010 ± 0.0010.189 ± 0.0110.005 ± 0.0000.008 ± 0.000
SinesEuclidean0.003 ± 0.0010.019 ± 0.0030.007 ± 0.0040.093 ± 0.000
Gram0.002 ± 0.0010.019 ± 0.0020.006 ± 0.0020.093 ± 0.000

From the above table, we can observe that the results are mixed. For instances, the Gram based loss can help the model achieve better Context-FID on Stocks and Sines, but it also produces worse performances on the fMRI and energy datasets. We will describe include the Gram weighting loss as an evaluated alternative for training the model, with the full comparison results for both losses.

Comments on the paper

2 comments
AuthorsOpenReview ↗

(1/2): Claims, Missing Baselines and Source of Speed-Ups

We thank Reviewers vJV8, pmVB and x2ZF for a detailed and productive discussion. Because the thread is long, this two-part comment consolidates it for the record. Part 1 covers the three concerns that cut across reviews: the strength of the empirical claims, the missing 2026 baselines, and the efficiency claim. Part 2 covers basis size and geometry, missing data and the tail behaviour. Every number below already appears in the thread during rebuttal period.

1. We have narrowed the empirical claims (vJV8, x2ZF).

The intervals in the submitted Tables 1–3 follow SMF's released workflow (five fitted TS2Vec encoders on a fixed generated set, 95% Student-t half-widths; Appendix C.3); they measure evaluator variance, not training-seed variance. We therefore trained five independent generators per method. With generator-level std, GF's Context-FID advantage is clear and separated on ETTh1 (0.010±0.001 vs SMF 0.057±0.007, OFM 0.025±0.002) and MuJoCo (0.010±0.001 vs SMF 0.022±0.002, OFM 0.017±0.002). It is competitive rather than separated on Energy (0.048±0.001 vs SMF 0.052±0.003, OFM 0.055±0.019), fMRI (0.106±0.021 vs SMF 0.112±0.002, OFM 0.115±0.003) and Sines (0.002±0.001 vs SMF 0.005±0.001, OFM 0.002±0.001). SMF is better on Stocks (0.012±0.004 vs 0.018±0.004). This does not support a general SOTA claim, and we no longer make one; the "particularly large" Energy description is withdrawn as well. The revision will remove "lowest on all six" and "SOTA" from the abstract and introduction, state each improvement with its dataset, metric and comparator, report both uncertainty sources, and stop reading overlapping intervals as equivalence. Predictive scores that coincide at the reported precision will be called near-ties. Diffusion-TS now has five-seed results too. Table 3 remains favourable on average but includes close cases (70% missing: 0.016 vs 0.015).

2. The 2026 baselines are now evaluated and discussed (vJV8).

Functional Mean Flow. We adapted FMF with its mean-velocity objective (JVP and stop-gradient retained) and evaluated one-step and few-step sampling on all six regular and both long-horizon datasets under the same protocol as our other baselines. GF has the lower mean Context-FID on all six (Stocks 0.009 vs 0.573; ETTh1 0.014 vs 1.065; Energy 0.029 vs 0.484; fMRI 0.108 vs 0.112; MuJoCo 0.008 vs 0.013; Sines 0.003 vs 0.009) and better Marginal, Classification and Predictive scores on FRED-MD and NN5 Daily; FMF is better on Sines correlation. We also correct our earlier statement: FMF's Table 1 and Appendix C.1 do evaluate time-series data, so it is directly relevant prior work, and Section 2 will say so.

Functional Attention. The distinction is where the basis lives: FA learns an adaptive basis inside the attention operator, while GF fixes a continuous synthesis basis and learns the coefficient distribution; FA is an attention mechanism for operator learning, not a complete unconditional generator. Inserting FA's core into GF's velocity network improved only Stocks (0.006 vs 0.009) and Sines (0.002 vs 0.003) and degraded ETTh1, Energy, fMRI and MuJoCo, so we retain the simpler backbone.

3. The speed-up comes from the long grid and the velocity parameterisation, not from basis compression at N=24 (vJV8, x2ZF).

x2ZF is right that K=32>N=24K=32>N=24 gives no token compression and we withdraw that attribution. We measured the released SMF implementation end to end. A full update (objective, backward, clipping, optimizer, scheduler, EMA) is 4.05–9.04× cheaper for GF on all six regular datasets at N=24 (Stocks 4.47×, ETTh1 4.58×, Energy 5.67×, fMRI 7.58×, MuJoCo 9.04×, Sines 4.05×), so a complete GF update takes 11–25% of SMF's time. Model size does not explain this: on Stocks SMF has fewer parameters than GF (0.36M vs 0.52M) yet is 4.47× slower. On NN5 Daily (N=791), the selected GF-K256 configuration uses 16.16M parameters and 74.9 ms per update versus SMF's 100.57M and 410.8 ms, i.e. 5.49× per update and about 5.7× faster sampling; a K32 control is faster still (36.1 ms per update). The mechanism is the velocity parameterisation: SMF differentiates a learned witness and backpropagates through that input gradient, whereas GF predicts coefficient velocity directly. Revised Section 5.5 and Appendix F.7 report these measurements and claim only what they support: a lighter velocity parameterisation at short windows and a smaller repeated state at long ones.

We hope this record helps the AC and reviewers and the Part 2 continues below.

AuthorsOpenReview ↗

(2/2): Representation, Robustness and Revision Map

4. K=32 is an experimental configuration, and we now document it as one (vJV8, pmVB, x2ZF).

The theory does not prescribe K. We agree that 24 observations leave eight coefficient directions per channel undetermined and that ridge regression only returns a regularised solution without adding information.

(a) A new recorded Stocks sweep (seed 42, SMF recipe) replaces the inconsistent Tables 9 and 18: K=16/24/32/36/40/48/96K=16/24/32/36/40/48/96 gives mean Context-FID 0.010/0.011/0.009/0.020/0.012/0.018/0.019; K=32K=32 has the best mean, but the trend is not monotone.

(b) A cross-resolution test on ETTh1 keeps every fourth of 93 hourly measurements (24 fitting targets) and decodes the generated coefficients at all 93 positions: K=32K=32 gives Context-FID 0.136 versus 3.605 for K=24K=24, and its fit error at the 69 unseen positions is 0.052 versus 0.425. We will present K=32K=32 as the submitted configuration, state that compression requires K<NK<N (not satisfied at N=24N=24), and replace Table 6 (reconstruction only) with the four-metric cross-resolution table. On x2ZF's point that this contradicts our analysis: the rank argument predicts identifiability, not accuracy, and the experiment shows that removing the null space with K=NK=N does not by itself improve off-grid fit, because the 24×24 fit is ill-conditioned. We will state that distinction explicitly.

5. Gram versus Euclidean geometry is now both argued and measured (vJV8).

With prior and path fixed, both objectives share the same ideal predictor, the conditional mean velocity; the Gram matrix reweights error directions and bounds the Gram-weighted squared velocity error by λmax(G) times the Euclidean one. Empirically the choice is mixed: Gram helps on Stocks (0.006 vs 0.009), ETTh1 (0.010 vs 0.014) and Sines (0.002 vs 0.003), and hurts on MuJoCo (0.010 vs 0.008), Energy (0.032 vs 0.029) and fMRI (0.128 vs 0.108). We keep Euclidean as the default, report the Gram variant as an alternative, and state in Section 3 that the Gram geometry motivates the analysis while the deployed loss is Euclidean.

6. Missing data: linear filling is a tested design choice, not an oversight (vJV8, pmVB).

Two controlled Stocks studies separate the effects.

(a) Fixing the masked loss and changing only coefficient fitting: linear-fill-then-ridge beats observed-only ridge at 50% missing (0.011 vs 0.589) and 70.8% (0.021 vs 1.630) on all four metrics.

(b) Fixing the filled curves and changing only the loss support: the observed-only mask lowers Context-FID in all four settings (observed vs all: 50% random 0.009 vs 0.022; 50% block 0.011 vs 0.032; 70.8% random 0.014 vs 0.037; 70.8% block 0.021 vs 0.061), with mixed effects on the other metrics. We will present interpolation as part of the fitting prior, note that bias grows when gaps span non-linear or high-frequency segments, and leave adaptive or learned filling to future work.

7. Tail behaviour is a limitation we now quantify (pmVB).

We agree that cubic splines smooth sharp transients and that average metrics hide this. On Stocks increment tails, a nonlinear autoencoder is comparable on tail-quantile error to K=32 splines (85.4 vs 87.1, 10⁻³ units) and is much better on kurtosis (2.10 vs 5.45). On synthetic shocks, larger K helps event amplitude (0.349 to 0.067 for K=16 to 48) and chirp content (0.291 to 0.002), but not monotonically for pulse q.999. Generated increments still have far smaller fourth moments. We will not claim tail fidelity; Section 6 will be expanded with these diagnostics and the fourth-moment result.

8. Remaining requests (pmVB).

The added baselines were run at matched NFE; GF keeps the lowest or tied mean Context-FID on five of six datasets (OFM is better on Stocks), and revised tables will state the budget for every entry, including the 40–50 NFE operating point. Learned latent baselines (functional PCA, learned global basis, continuous autoencoder) are now compared on all six datasets: fixed splines have lower mean Context-FID than fPCA on 5/6, than the autoencoder on 6/6, and than the learned basis on 5/6, and widening the autoencoder does not close the gap (fMRI 0.415 vs 0.108; Energy 0.244 vs 0.029). References will be added beside every baseline name in Tables 1–3.

9. A Guide to the Revision map.

§1: claims narrowed, dataset-specific

§2 FMF and FA discussion with corrected FMF scope

§3 K as a configuration and the Euclidean/Gram distinction

§4 scope of the bound and its assumptions

§5 generator-level std, NFE, citations, revised Table 10. §5.4 and Appendix B new K sweep, Table 6 replacement, cross-resolution, missing-data controls, tail diagnostics, latent baselines, efficiency benchmark.

The contribution we retain is the coefficient-space formulation, its error decomposition, and a measured long-grid computational advantage.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.