The ANTIC adaptive neural temporal in-situ compressor will compress PDE trajectories more effectively if its error-budget allocation across timesteps is chosen by Bayesian optimisation with a UCB acquisition (as for diffusion-sampling timestep selection), yielding a better rate-distortion trade-off than uniform or hand-designed timestep schedules at equal storage.

For a fixed total storage budget B (bytes/GB) encoding a PDE trajectory with ANTIC, allocating per-timestep error tolerances via Bayesian optimization with a Gaussian-Process surrogate and UCB acquisition (searching over the simplex of per-interval error budgets) will achieve a lower reconstruction error (measured as mean relative L2 norm and max-norm over held-out rollout steps) than (a) uniform error-budget allocation and (b) at least two hand-designed heuristic schedules (e.g., front-loaded, curvature-adaptive), at matched compressed size (±2%), across at least 4 of 5 benchmark PDE systems (Navier-Stokes 2D, Burgers, shallow-water, reaction-diffusion, Kuramoto-Sivashinsky), with the improvement being ≥8% relative reduction in distortion (PSNR gain ≥0.8 dB equivalent) at p<0.05 over ≥5 random seeds.

Minimum viable test: single PDE system (2D Navier-Stokes, vorticity formulation, Re=1000, 64×64 grid, 200 timesteps), compare 3 conditions — (1) uniform error budget, (2) UCB-BO allocated budget (GP surrogate over 20 binned timestep groups, 100 BO iterations), (3) one hand-designed heuristic (curvature/∂²u/∂t²-weighted) — at 3 matched storage ratios (10x, 50x, 200x compression) with 5 random seeds each. Measure relative L2 error, PSNR, and per-timestep error distribution. Full validation extends to 5 PDE systems × 3 storage ratios × 5 seeds × 3 methods = 225 runs.

# Pseudocode
for pde_system in [NS2D, Burgers, ShallowWater, ReacDiff, KS]:
    traj = load_trajectory(pde_system)
    bins = partition_timesteps(traj, n_bins=20)

    def encode_decode_distortion(budget_allocation):
        # budget_allocation: vector in simplex, len=n_bins, sums to total_storage
        compressed = ANTIC.encode(traj, per_bin_tolerance=budget_allocation)
        size = compressed.nbytes
        recon = ANTIC.decode(compressed)
        distortion = relative_L2(traj, recon)
        return distortion, size

    # Baseline 1: uniform
    uniform_alloc = total_budget / n_bins * ones(n_bins)
    d_uniform, s_uniform = encode_decode_distortion(uniform_alloc)

    # Baseline 2: heuristic (curvature-weighted)
    curvature = second_derivative_norm(traj, bins)
    heuristic_alloc = project_to_simplex(curvature, total_budget)
    d_heur, s_heur = encode_decode_distortion(heuristic_alloc)

    # Method: GP-UCB Bayesian optimization
    gp = GaussianProcessSurrogate()
    X_init = random_simplex_samples(n=10, dim=n_bins, total=total_budget)
    Y_init = [ -encode_decode_distortion(x)[0] for x in X_init ]  # maximize -distortion
    gp.fit(X_init, Y_init)

    for iter in range(150):
        kappa = anneal(2.0, 0.5, iter, 150)
        x_candidate = maximize_UCB(gp, kappa, constraint=simplex(total_budget))
        d, s = encode_decode_distortion(x_candidate)
        gp.update(x_candidate, -d)

    best_alloc = gp.get_best_x()
    d_bo, s_bo = encode_decode_distortion(best_alloc)

    log_results(pde_system, d_uniform, d_heur, d_bo, s_uniform, s_heur, s_bo)

# Statistical comparison across seeds/systems
wilcoxon_test(d_bo_all_seeds, d_uniform_all_seeds)
wilcoxon_test(d_bo_all_seeds, d_heur_all_seeds)