△ Mechanism confirmed, baseline not beaten 2026

Resolution-aware operator data budget

Implementation & benchmark of arXiv:2607.06287 — Kernel-based Operator Learning: Error Analysis, Budget Allocation, and a Physics-Informed Extension

Usefulness6/10

Difficulty4/10

Novelty7/10

Training Scalability Sample efficiency Neural operator Training Sample efficiency Scalability Approximation theory Metric geometry Numerical analysis Statistics

Source paper: Kernel-based Operator Learning: Error Analysis, Budget Allocation, and a Physics-Informed Extension arXiv:2607.06287 ⓘ · analyzed Aug 30, 2026

AI-generated research hypothesis, automatically tested. Not peer-reviewed.

Idea description

Couple the number of operator training pairs to the output resolution instead of increasing the output grid independently. Refine the output discretization only while the oracle reconstruction improves, and increase the training set when the learned predictor remains substantially worse than the oracle decoder.

Formulas

$$h_{\Xi,D}:=\sup_{\boldsymbol{\xi}\in D}\min_{1\leq i\leq M}\|\boldsymbol{\xi}-\boldsymbol{\xi}_{i}\|_{V}.$$

$$h_{\{\boldsymbol{u}_{i}\},S_{\Phi}(\mathcal{M})}\leq h_{0},\qquad \iota_{\Phi}(u):=\inf_{w\in\ker S_{\Phi}}\|u-w\|_{\mathcal{U}}.$$

$$\mathcal{A}=A_{\mathrm{on}}\circ A_{\mathrm{off}}\circ S_X,\qquad \boldsymbol v^\dagger=S_Y(\mathcal G(u)),\qquad \widehat{\boldsymbol v}=A_{\mathrm{off}}(S_X(u)).$$

$$N(m)=\left\lceil C_Nm^\kappa\right\rceil,\qquad \kappa\in\{0.5,1.0,1.5\}.$$

Mathematical statement

For a finite set $\Xi=\{\boldsymbol\xi_i\}_{i=1}^M$ in a domain $D$, the paper defines the fill distance $h_{\Xi,D}=\sup_{\boldsymbol\xi\in D}\min_i\|\boldsymbol\xi-\boldsymbol\xi_i\|_V$. For a compact input class $\mathcal M$, the discretized training inputs $\boldsymbol u_i$ should cover $S_\Phi(\mathcal M)$, with $h_{\{\boldsymbol u_i\},S_\Phi(\mathcal M)}\le h_0$. The information loss from input observations is $\iota_\Phi(u)=\inf_{w\in\ker S_\Phi}\|u-w\|_{\mathcal U}$. The surrogate is $\mathcal A=A_{\mathrm{on}}\circ A_{\mathrm{off}}\circ S_X$, with exact output observations $\boldsymbol v^\dagger=S_Y(\mathcal G(u))$ and predicted observations $\widehat{\boldsymbol v}=A_{\mathrm{off}}(S_X(u))$. Its total error separates reconstruction error of $A_{\mathrm{on}}$ from learning error of $A_{\mathrm{off}}$. The reported experiment used $N=m^\kappa$: $\kappa=0.5$ stagnated, while $\kappa\ge1$ reached the oracle rate. The engineering rule is therefore to test $N(m)=\lceil C_Nm^\kappa\rceil$, initially with $\kappa\in\{0.5,1,1.5\}$, and stop increasing $m$ when the learned-oracle gap dominates.

Implementation notes

Apply this to an FNO, DeepONet, or operator transformer whose output has an explicit number $m$ of spatial points or output tokens. For each candidate resolution $m$, train an oracle reconstruction model using exact output observations and record $E_{\mathrm{oracle}}(m)$. Then train the actual neural operator using $N=\lceil C_Nm^\kappa\rceil$ input/output pairs, testing $\kappa=0.5,1.0,1.5$. Estimate input coverage on a held-out validation set $V$ through the sampled-feature proxy $\widehat h=\max_{u\in V}\min_i\|S_X(u)-S_X(u_i)\|_2$. At each resolution, measure learned error $E_{\mathrm{learned}}(m,N)$, oracle error, total training FLOPs, and wall-clock cost. If increasing $m$ lowers oracle error but leaves learned error unchanged, increase $N$; if both errors stagnate, stop refining the grid. If the learned/oracle gap is small, additional training pairs are unnecessary. The first cheap experiment is 2D Poisson or Darcy flow at grids 32, 64, and 128, using the same FNO architecture and optimizer for all conditions. Compare against a fixed-$N$ baseline and plot error versus training FLOPs. Success is lower error at equal data or compute, with the learned curve approaching the oracle curve near linear scaling $N\propto m$.

Verification

Mechanism confirmed, baseline not beaten

Stage 1 · Toy mechanism gate: Passed ✓

Stage 2 · Mechanism transferred to benchmark: Confirmed ✓

Stage 2 · Practical benchmark result: No measurable effect

Methodology: 8 paired seeds, permutation test (p<0.05) against a learning-rate-tuned baseline. How verification works

Stage 1 — Mechanism check agent confidence 8/10

Built a compact kernel-based two-stage operator-learning MVP with exact-output cubic reconstruction, learned offline kernel regression, fill-distance verification, a fixed-N baseline, and N=ceil(m^kappa) schedules. The math check reproduced uniform fill distance h=1/(2(m-1)) to numerical precision with log-log slope -1.09. In the toy operator, fixed N=16 stagnated at errors 0.720, 0.727, 0.728 for m=16,32,64, while kappa=1.0 improved to 0.720, 0.632, 0.470 and kappa=1.5 reached 0.471, 0.310, 0.311; the oracle error fell from 0.204 to 0.0142 to 0.000385. This is a clear qualitative signal supporting resolution-aware data growth, but not evidence of superiority at equal compute because larger N costs more.

Agent confidence: 8/10

Baseline: Fixed N=16 learned relative L2 error: m=16 0.7202, m=32 0.7273, m=64 0.7276; wall time approximately 0.162-0.164 seconds.
Idea: For kappa=1.0, N=16,32,64 gives relative L2 errors 0.7202, 0.6322, 0.4700; for kappa=1.5, N=64,128,128 gives 0.4710, 0.3099, 0.3113. Oracle errors are 0.2040, 0.01424, 0.000385.

Limitations: This is a small synthetic smooth operator and kernel regressor rather than an FNO, DeepONet, or PDE benchmark. The kappa=1.5 schedule is capped at N=128 at m=64, only one random train/test split was used, wall-clock measurements are noisy, and no equal-FLOP comparison or GPU run was performed.

How to run: python3 resolution_budget_experiment.py

Stage 2 — Benchmark vs. tuned baseline (arXiv:2607.06287) Sep 4, 2026

No significant difference vs. the tuned baseline (−-0.0%, p=1, wins 0 / 0 paired seeds).

Benchmark: Poisson_jfb_short_trace
Model: mlp_tiny
Paired seeds: 8
Baseline mean: 0.0011
Idea mean: 0.0011
Effect (Δ): 0 (−-0.0%; negative = idea better)
Wins: 0 / 0 paired seeds
p-value: 1 (permutation test, 20 000 shuffles)
Smallest detectable effect: n/a
Mechanism: Confirmed ✓
Practical effect: No effect
Baseline tuning: swept over 0 configs

Limitations:

The matched PDE track has a fixed 30-point output grid; the resolution audit used nested subsampling at m=10,20,30 rather than independently generated high-resolution PDE grids. FLOPs were not directly counted. The baseline was allowed to use the largest data budget, so the experiment demonstrates a data-quality mechanism but not a savings or equal-budget advantage.

How to run: python3 stage2_bench.py

Verdict computed by deterministic test code from paired-seed statistics — not by the language model.

Stage 2 — Benchmark Sep 4, 2026 latest Failed ✗

Agent confidence: 10/10

The resolution-aware schedule was implemented and tested on the structurally matched Poisson PDE track with the shared mlp_tiny architecture and canonical train_model path. Increasing training pairs improved trained-model MSE from 0.0100713 at N=6 to 0.00284859 at N=30 and 0.00102006 at N=165, confirming the mechanism. The tuned baseline selected lr=0.006 and N=165, exactly matching the best idea result; paired delta_mean=0 and permutation p=1.0, so there was no significant benchmark win.

Baseline: 8-seed mean MSE 0.0011491459, std 0.0001594221; best config lr=0.006, n_train=165.
Idea: Best 8-seed result: kappa=1.5, N=165, lr=0.006, mean MSE 0.0011491459, std 0.0001594221.
Mechanism signature: confirmed=true; observed MSE decreased from 0.0100713 at N=6 to 0.00284859 at N=30 and 0.00102006 at N=165.
Paired comparison: delta_mean=0.0, p_value=1.0, verdict=no measurable effect

Benchmark result