Upload folder using huggingface_hub

ballast/experiment.py

@@ -0,0 +1,289 @@
+"""Active-learning campaign driver (paper Sec. 5.2 / 5.3).
+
+A campaign deploys M Lagrangian observers, one every `deploy_every` units of
+time, the first uniformly at random and the rest by the policy under test. Each
+observer is advected by the *ground-truth* field from its release until the
+terminal time T (or until it leaves the region) and measures every delta_obs.
+
+Performance after m deployments is the average L2 error of the GP posterior
+predictive mean field over the spatial grid and the full set of deployment
+times, using all data those m observers collect over the whole campaign -- i.e.
+"what would this campaign have bought me if I had stopped at m drifters".
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Callable
+
+import jax
+import jax.numpy as jnp
+import numpy as np
+from scipy.optimize import minimize
+
+from .gp import log_marginal_likelihood, posterior_ext_state, posterior_mean_field
+from .kernels import HelmParams
+from .policies import (
+    ballast_sample_utilities,
+    dist_sep_scores,
+    eig_utilities,
+    sobol_indices,
+)
+from .spde import make_ops, prior_sample
+from .trajectory import Grid, advect, observe
+
+
+@dataclass
+class Config:
+    T: float = 10.0
+    dt: float = 0.01
+    obs_every: int = 5  # delta_obs = 0.05
+    deploy_every: float = 0.5
+    n_deploy: int = 20  # 1 initial + 19 policy-chosen
+    sigma_obs: float = 0.1
+    n_samples: int = 20  # BALLAST J
+    grid_nx: int = 25
+    grid_ny: int = 25
+    x_lo: float = -2.0
+    x_hi: float = 2.0
+    y_lo: float = -2.0
+    y_hi: float = 2.0
+    chunk: int = 64
+
+    @property
+    def n_obs_total(self) -> int:
+        return int(round(self.T / self.dt)) // self.obs_every
+
+    @property
+    def obs_dt(self) -> float:
+        return self.dt * self.obs_every
+
+    def grid(self) -> Grid:
+        return Grid(
+            jnp.linspace(self.x_lo, self.x_hi, self.grid_nx),
+            jnp.linspace(self.y_lo, self.y_hi, self.grid_ny),
+        )
+
+
+SYNTH_PARAMS = HelmParams(
+    phi_ls=0.8, phi_var=0.5, psi_ls=0.5, psi_var=0.5, time_ls=2.5, time_var=1.0
+)
+
+# Sec. H.3 optimisation bounds ("uniform priors with finite support")
+SYNTH_BOUNDS = [(0.1, 1.0), (0.1, 1.0), (0.1, 1.0), (0.1, 1.0), (0.1, 3.0), (0.1, 3.0)]
+SUNTANS_BOUNDS = [(0.1, 5.0), (10.0, 20.0), (0.1, 1.0), (0.1, 5.0), (0.1, 3.0), (10.0, 20.0)]
+
+
+def make_ground_truth(key, cfg: Config, p: HelmParams) -> jnp.ndarray:
+    """Draw a synthetic ground-truth field from the temporal Helmholtz GP.
+
+    Exact draw via the SPDE prior (dense sampling of 25*25*1001 space-time points
+    would be a ~1.25M-dimensional Gaussian).
+    """
+    grid = cfg.grid()
+    ops = make_ops(grid.R, p, cfg.dt)
+    n_steps = int(round(cfg.T / cfg.dt))
+    return prior_sample(key, grid.R, ops, n_steps)
+
+
+def optimise_hypers(
+    S, t, y, cfg: Config, bounds, init: HelmParams, opt_noise: bool = True
+):
+    """L-BFGS-B fit of the GP hyperparameters (Algorithm 2 step 5, Sec. H.3).
+
+    Optimises in the natural parameterisation with box bounds, as the paper
+    describes ("manually-set bounds ... to mimic uniform priors with finite
+    support"). Falls back to the initial values if the optimiser fails.
+    """
+    b = list(bounds) + ([(0.01, 1.0)] if opt_noise else [])
+    x0 = np.array(list(np.asarray(init.as_array())) + ([cfg.sigma_obs] if opt_noise else []))
+    x0 = np.clip(x0, [lo for lo, _ in b], [hi for _, hi in b])
+
+    def obj(x):
+        x = jnp.asarray(x)
+        p = HelmParams.from_array(x[:6])
+        sig = x[6] if opt_noise else cfg.sigma_obs
+        return -log_marginal_likelihood(p, S, t, y, sig)
+
+    vg = jax.jit(jax.value_and_grad(obj))
+
+    def f(x):
+        v, g = vg(jnp.asarray(x))
+        return float(v), np.asarray(g, dtype=np.float64)
+
+    try:
+        res = minimize(f, x0, jac=True, method="L-BFGS-B", bounds=b,
+                       options={"maxiter": 60})
+        xs = np.clip(res.x, [lo for lo, _ in b], [hi for _, hi in b])
+    except Exception:
+        xs = x0
+    p = HelmParams.from_array(jnp.asarray(xs[:6]))
+    sig = float(xs[6]) if opt_noise else cfg.sigma_obs
+    return p, sig
+
+
+def run_campaign(
+    key,
+    cfg: Config,
+    gt_fields: jnp.ndarray,
+    policy: str,
+    true_params: HelmParams,
+    bounds=None,
+    eval_params: HelmParams | None = None,
+    seed_offset: int = 0,
+):
+    """Run one campaign. Returns dict with the per-deployment error curve.
+
+    `eval_params` (default: true_params) are the hyperparameters used for the
+    *evaluation* GP. Held fixed across policies so the comparison measures the
+    quality of the data collected, not of the fitted model.
+    """
+    grid = cfg.grid()
+    eval_params = eval_params or true_params
+    n_obs_tot = cfg.n_obs_total
+    ops_true = make_ops(grid.R, true_params, cfg.dt)
+
+    # global observation times: 0.05, 0.10, ..., T
+    tg = cfg.obs_dt * (1 + jnp.arange(n_obs_tot))
+
+    pos_all = np.zeros((cfg.n_deploy, n_obs_tot, 2))  # reported (cell-centre) locations
+    raw_all = np.zeros((cfg.n_deploy, n_obs_tot, 2))  # true physical positions
+    val_all = np.zeros((cfg.n_deploy, n_obs_tot), dtype=bool)
+    y_all = np.zeros((cfg.n_deploy, n_obs_tot, 2))
+    placements = []
+    errors = []
+
+    t_eval = cfg.deploy_every * jnp.arange(cfg.n_deploy)
+
+    for m in range(cfg.n_deploy):
+        t_m = m * cfg.deploy_every
+        k_m = int(round(t_m / cfg.dt))
+        key, kp, ks, ko = jax.random.split(key, 4)
+
+        # ---- data available at decision time (strictly before/at t_m)
+        past = val_all & (np.asarray(tg)[None, :] <= t_m + 1e-9)
+        S_obs = jnp.asarray(pos_all[past])
+        t_obs = jnp.asarray(np.broadcast_to(np.asarray(tg)[None, :], past.shape)[past])
+        y_obs = jnp.asarray(y_all[past])
+
+        # ---- choose the placement
+        if m == 0:
+            idx = int(jax.random.randint(kp, (), 0, grid.n))
+        elif policy == "unif":
+            idx = int(jax.random.randint(kp, (), 0, grid.n))
+        elif policy == "sobol":
+            idx = int(sobol_indices(grid, cfg.n_deploy, seed_offset)[m])
+        else:
+            exist_idx = np.arange(m)
+            j_at = int(round(t_m / cfg.obs_dt)) - 1  # obs index whose time is t_m
+            # project from the drifters' true positions, not their reported cells
+            exist_pos = jnp.asarray(raw_all[exist_idx, j_at])
+            exist_live = jnp.asarray(val_all[exist_idx, j_at])
+            # drifters that already left contribute nothing: park them outside
+            exist_pos = jnp.where(
+                exist_live[:, None], exist_pos, jnp.array([1e6, 1e6])
+            )
+
+            p_pol, sig_pol = true_params, cfg.sigma_obs
+            if policy == "ballast_opt":
+                p_pol, sig_pol = optimise_hypers(
+                    S_obs, t_obs, y_obs, cfg, bounds, true_params
+                )
+
+            if policy == "eig":
+                sc = eig_utilities(grid, S_obs, t_obs, t_m, p_pol, sig_pol, cfg.chunk)
+            else:
+                ops_pol = ops_true if policy != "ballast_opt" else make_ops(
+                    grid.R, p_pol, cfg.dt
+                )
+                mean, chol = posterior_ext_state(
+                    S_obs, t_obs, y_obs, grid.R, t_m, p_pol, sig_pol
+                )
+                if policy == "dist_sep":
+                    sc = dist_sep_scores(
+                        ks, grid, ops_pol, mean, chol, exist_pos, S_obs, t_m,
+                        cfg.T, cfg.dt, cfg.obs_every, cfg.n_samples,
+                    )
+                else:  # ballast_true / ballast_opt
+                    u = ballast_sample_utilities(
+                        ks, grid, ops_pol, S_obs, t_obs, mean, chol, exist_pos,
+                        t_m, cfg.T, cfg.dt, cfg.obs_every, p_pol, sig_pol,
+                        cfg.n_samples, cfg.chunk,
+                    )
+                    sc = jnp.mean(u, axis=0)
+            idx = int(jnp.argmax(sc))
+
+        s_new = grid.R[idx]
+        placements.append((float(s_new[0]), float(s_new[1]), t_m))
+
+        # ---- advect the new drifter through the TRUE field until T
+        pos, valid, tidx = advect(
+            grid, gt_fields[k_m:], s_new[None, :],
+            jnp.ones(1, dtype=bool), cfg.dt, cfg.obs_every,
+        )
+        yv = observe(ko, grid, gt_fields[k_m:], pos, valid, tidx, cfg.sigma_obs)
+        j0 = int(round(t_m / cfg.obs_dt))
+        n_here = pos.shape[0]
+        # a drifter reports its cell's velocity, i.e. f(cell centre, t) + noise
+        pos_all[m, j0 : j0 + n_here] = np.asarray(grid.snap(pos)[:, 0, :])
+        raw_all[m, j0 : j0 + n_here] = np.asarray(pos[:, 0, :])
+        val_all[m, j0 : j0 + n_here] = np.asarray(valid[:, 0])
+        y_all[m, j0 : j0 + n_here] = np.asarray(yv[:, 0, :])
+
+        # ---- evaluate: all data from the m+1 drifters over the whole campaign
+        sel = val_all[: m + 1]
+        S_e = jnp.asarray(pos_all[: m + 1][sel])
+        t_e = jnp.asarray(np.broadcast_to(np.asarray(tg)[None, :], sel.shape)[sel])
+        y_e = jnp.asarray(y_all[: m + 1][sel])
+        mu = posterior_mean_field(
+            S_e, t_e, y_e, grid.R, t_eval, eval_params, cfg.sigma_obs
+        )
+        gt_at_eval = gt_fields[(jnp.round(t_eval / cfg.dt)).astype(int)]
+        err = float(jnp.mean(jnp.linalg.norm(mu - gt_at_eval, axis=-1)))
+        errors.append(err)
+
+    return {
+        "policy": policy,
+        "errors": errors,
+        "placements": placements,
+        "n_obs": int(val_all.sum()),
+    }
+
+
+# --------------------------------------------------------------------------
+# Iso-performance (Sec. 5.2): how many drifters a policy saves vs UNIF
+# --------------------------------------------------------------------------
+
+
+def iso_performance(err_policy: np.ndarray, err_unif: np.ndarray) -> np.ndarray:
+    """Drifters saved at each iteration, relative to the uniform benchmark.
+
+    At iteration m the uniform benchmark reaches error e = err_unif[m]. We find
+    the (interpolated, fractional) number of drifters n the policy needs to reach
+    the same error and report m - n: positive means the policy needed fewer.
+
+    Both curves are made monotone non-increasing first (running minimum): the
+    error curve of a single run is noisy, and "the number of drifters needed to
+    reach accuracy e" is only well defined for a best-so-far curve.
+    """
+    a = np.minimum.accumulate(np.asarray(err_policy, dtype=float))
+    b = np.minimum.accumulate(np.asarray(err_unif, dtype=float))
+    n = len(a)
+    idx = np.arange(1, n + 1, dtype=float)  # number of drifters deployed
+    out = np.full(n, np.nan)
+    for m in range(n):
+        target = b[m]
+        hit = np.where(a <= target)[0]
+        if len(hit) == 0:
+            # policy never reaches it: cap at the full budget (conservative)
+            out[m] = idx[m] - (n + 1)
+            continue
+        k = hit[0]
+        if k == 0:
+            out[m] = idx[m] - 1.0
+        else:
+            # linear interpolation in drifter count between k-1 and k
+            e0, e1 = a[k - 1], a[k]
+            frac = 0.0 if e0 == e1 else (e0 - target) / (e0 - e1)
+            out[m] = idx[m] - (idx[k - 1] + frac)
+    return out

ballast/gp.py

@@ -0,0 +1,197 @@
+"""GP regression, posterior sampling and information-gain utilities.
+
+Implements paper Sec. B.1 (regression), C.1 (the cheap EIG reformulation
+logdet(I + sigma^-2 K(X)), which is what eq. (3)/(5) actually mean -- see note
+below), and E.2 (rank-q Gram determinant updates, which the paper states is
+"the default for the computation in this work").
+
+Note on eq. (5). The main text writes the utility as
+    logdet(I + sigma_obs^2 K(X))
+but App. C.1 derives
+    IG = 1/2 logdet(I + sigma_obs^{-2} K(X)),
+i.e. the noise variance enters *inversely* (more noise -> less information). The
+main-text form is a sign-of-exponent typo; we implement the App. C.1 form. With
+sigma_obs = 0.1 the two differ by a factor 1e4 inside the logdet and would order
+candidates differently, so this matters. Constant factors of 1/2 do not affect
+the argmax and are dropped, but we keep them consistent across policies.
+"""
+
+from __future__ import annotations
+
+import jax
+import jax.numpy as jnp
+from jax.scipy.linalg import cho_factor, cho_solve, solve_triangular
+
+from .kernels import HelmParams, k_ext_cross, k_ext_full, k_thelm_mat
+
+
+def _expand_mask(mask: jnp.ndarray) -> jnp.ndarray:
+    """(..., n) point mask -> (..., 2n) row mask (2 velocity components/point)."""
+    return jnp.repeat(mask, 2, axis=-1)
+
+
+def noise_gram(
+    S: jnp.ndarray, t: jnp.ndarray, p: HelmParams, sigma: float, mask=None
+) -> jnp.ndarray:
+    """M = I + sigma^-2 K(X), with invalid points replaced by identity rows.
+
+    Masking out point i (row/col -> e_i) leaves logdet(M) equal to the logdet of
+    the submatrix over valid points, so variable-length trajectories can be
+    batched at fixed shape.
+    """
+    K = k_thelm_mat(S, t, S, t, p)
+    n = K.shape[0]
+    M = jnp.eye(n) + K / sigma**2
+    if mask is not None:
+        m = _expand_mask(mask).astype(M.dtype)
+        M = M * m[:, None] * m[None, :]
+        M = M + jnp.diag(1.0 - m)
+    return M
+
+
+def logdet_chol(M: jnp.ndarray) -> jnp.ndarray:
+    L = jnp.linalg.cholesky(M)
+    return 2.0 * jnp.sum(jnp.log(jnp.diagonal(L, axis1=-2, axis2=-1)), axis=-1)
+
+
+# --------------------------------------------------------------------------
+# Regression
+# --------------------------------------------------------------------------
+
+
+def log_marginal_likelihood(
+    p: HelmParams, S: jnp.ndarray, t: jnp.ndarray, y: jnp.ndarray, sigma: float
+) -> jnp.ndarray:
+    """Log marginal likelihood of the plain (non-extended) temporal Helmholtz GP.
+
+    y is (n, 2) velocity observations; flattened point-major/component-minor.
+    """
+    K = k_thelm_mat(S, t, S, t, p)
+    n = K.shape[0]
+    A = K + (sigma**2) * jnp.eye(n)
+    c, low = cho_factor(A)
+    yy = y.reshape(-1)
+    alpha = cho_solve((c, low), yy)
+    ld = 2.0 * jnp.sum(jnp.log(jnp.diag(c)))
+    return -0.5 * yy @ alpha - 0.5 * ld - 0.5 * n * jnp.log(2 * jnp.pi)
+
+
+def posterior_mean_field(
+    S: jnp.ndarray,
+    t: jnp.ndarray,
+    y: jnp.ndarray,
+    R: jnp.ndarray,
+    t_eval: jnp.ndarray,
+    p: HelmParams,
+    sigma: float,
+) -> jnp.ndarray:
+    """Posterior predictive mean of the velocity field on R x t_eval.
+
+    Returns (n_teval, N_space, 2). Used for the performance metric of Sec. 5.2:
+    average L2 error of the posterior mean field over the spatial grid and the
+    full set of deployment times.
+    """
+    K = k_thelm_mat(S, t, S, t, p)
+    A = K + (sigma**2) * jnp.eye(K.shape[0])
+    c, low = cho_factor(A)
+    alpha = cho_solve((c, low), y.reshape(-1))
+
+    N = R.shape[0]
+    Rr = jnp.tile(R, (t_eval.shape[0], 1))  # (nt*N, 2)
+    tr = jnp.repeat(t_eval, N)
+    Kx = k_thelm_mat(S, t, Rr, tr, p)  # (2n, 2*nt*N)
+    mu = Kx.T @ alpha
+    return mu.reshape(t_eval.shape[0], N, 2)
+
+
+def posterior_ext_state(
+    S: jnp.ndarray,
+    t: jnp.ndarray,
+    y: jnp.ndarray,
+    R: jnp.ndarray,
+    t_m: float,
+    p: HelmParams,
+    sigma: float,
+    jitter: float = 1e-8,
+):
+    """Posterior of the extended state f(R, t_m) = [f, d_t f]^T given D_m.
+
+    This is step 6/8 of Algorithm 2: regress with the *extended* GP using a
+    standard dense GP, then hand the draw to the SPDE propagator. Observations
+    only ever touch the f-block; the d_t f block is reached through the
+    cross-covariance d_{t'} k_tHelm.
+
+    Returns (mean (4N,), chol of covariance (4N, 4N)).
+    """
+    K = k_thelm_mat(S, t, S, t, p)
+    A = K + (sigma**2) * jnp.eye(K.shape[0])
+    c, low = cho_factor(A)
+
+    N = R.shape[0]
+    tvec = jnp.full((N,), t_m)
+    K_ot = k_ext_cross(S, t, R, tvec, p)  # (2n, 4N)
+    K_tt = k_ext_full(R, tvec, p)  # (4N, 4N)
+
+    mean = K_ot.T @ cho_solve((c, low), y.reshape(-1))
+    cov = K_tt - K_ot.T @ cho_solve((c, low), K_ot)
+    cov = 0.5 * (cov + cov.T) + jitter * jnp.eye(cov.shape[0])
+    return mean, jnp.linalg.cholesky(cov)
+
+
+def sample_ext_state(key, mean, cov_chol, n_space: int) -> jnp.ndarray:
+    """Draw an extended state and reshape to the SPDE layout (2N_space, 2)."""
+    z = jax.random.normal(key, mean.shape, dtype=mean.dtype)
+    x = mean + cov_chol @ z
+    return x.reshape(2 * n_space, 2)
+
+
+# --------------------------------------------------------------------------
+# Utilities (information gain)
+# --------------------------------------------------------------------------
+
+
+def base_factor(
+    S: jnp.ndarray, t: jnp.ndarray, p: HelmParams, sigma: float, mask=None
+):
+    """Cholesky factor and logdet of A = I + sigma^-2 K(Z) for the fixed base set Z."""
+    A = noise_gram(S, t, p, sigma, mask)
+    L = jnp.linalg.cholesky(A)
+    return L, 2.0 * jnp.sum(jnp.log(jnp.diag(L)))
+
+
+def rank_q_logdet(
+    L_base: jnp.ndarray,
+    logdet_base: jnp.ndarray,
+    S_base: jnp.ndarray,
+    t_base: jnp.ndarray,
+    base_mask: jnp.ndarray | None,
+    S_new: jnp.ndarray,
+    t_new: jnp.ndarray,
+    new_mask: jnp.ndarray,
+    p: HelmParams,
+    sigma: float,
+) -> jnp.ndarray:
+    """logdet(I + sigma^-2 K(Z u P)) via the App. E.2 block-determinant update.
+
+        det [[A, B], [B^T, D]] = det(A) det(D - B^T A^{-1} B)
+
+    with A = I + sigma^-2 K(Z) already factorised (independent of the candidate),
+    B = sigma^-2 K(Z, P), D = I + sigma^-2 K(P). Cost is O(n^2 q + q^3) per
+    candidate instead of O((n+q)^3), which is what makes the 625-candidate x
+    20-sample inner loop of Algorithm 2 affordable.
+
+    Masked-out new points contribute e_i rows to the Schur complement and hence
+    nothing to the logdet.
+    """
+    B = k_thelm_mat(S_base, t_base, S_new, t_new, p) / sigma**2  # (2n, 2q)
+    D = noise_gram(S_new, t_new, p, sigma, new_mask)  # (2q, 2q)
+
+    mnew = _expand_mask(new_mask).astype(B.dtype)
+    B = B * mnew[None, :]
+    if base_mask is not None:
+        B = B * _expand_mask(base_mask).astype(B.dtype)[:, None]
+
+    V = solve_triangular(L_base, B, lower=True)  # (2n, 2q)
+    Sc = D - V.T @ V
+    # keep the masked rows/cols exactly e_i (V columns there are already zero)
+    return logdet_base + logdet_chol(Sc)

ballast/kernels.py

@@ -0,0 +1,187 @@
+"""Kernels for the temporal Helmholtz GP of BALLAST (arXiv 2509.26005).
+
+The surrogate is a separable, vector-output, spatio-temporal GP
+
+    k_tHelm((s,t),(s',t')) = k_Helm(s,s') * k_time(t,t')
+
+with k_Helm the Helmholtz kernel of Berlinghieri et al. (2023) (paper Sec. B.2)
+built from two independent RBF kernels (potential Phi, stream Psi), and k_time a
+Matern-3/2 kernel (paper Sec. 2.2).
+
+Section 4.1 of the paper additionally needs the *extended* GP f = [f, d_t f]^T,
+whose kernel is the 2x2 block matrix of temporal derivatives of k_tHelm. Because
+k_tHelm is separable, all t-derivatives act on the Matern-3/2 factor only.
+
+Everything is implemented **analytically**. The paper (Sec. H.2) warns that
+autodiff through a Matern kernel written with a clipped distance
+(`sqrt(max(sum((x-y)**2), 1e-36))`, as in GPJax) gives d^2_{tt'}k = 0 at t=t'
+instead of the correct 3*sigma^2/l^2; the analytic form has no such problem.
+`tests/test_kernels.py` checks these derivatives against finite differences.
+
+Index layout
+------------
+Spatial-velocity blocks are flattened point-major / component-minor:
+    row index of a velocity vector at point i, component c  ->  i*2 + c
+The extended state adds the [f, d_t f] axis last:
+    (i, c, a)  ->  i*4 + c*2 + a          with a=0 -> f, a=1 -> d_t f
+"""
+
+from __future__ import annotations
+
+from typing import NamedTuple
+
+import jax
+import jax.numpy as jnp
+
+SQRT3 = jnp.sqrt(3.0)
+
+
+class HelmParams(NamedTuple):
+    """Hyperparameters of the temporal Helmholtz GP."""
+
+    phi_ls: jnp.ndarray  # potential kernel lengthscale
+    phi_var: jnp.ndarray  # potential kernel variance
+    psi_ls: jnp.ndarray  # stream kernel lengthscale
+    psi_var: jnp.ndarray  # stream kernel variance
+    time_ls: jnp.ndarray  # Matern-3/2 temporal lengthscale
+    time_var: jnp.ndarray  # Matern-3/2 temporal variance
+
+    def as_array(self) -> jnp.ndarray:
+        return jnp.stack(
+            [
+                jnp.asarray(self.phi_ls),
+                jnp.asarray(self.phi_var),
+                jnp.asarray(self.psi_ls),
+                jnp.asarray(self.psi_var),
+                jnp.asarray(self.time_ls),
+                jnp.asarray(self.time_var),
+            ]
+        )
+
+    @staticmethod
+    def from_array(a: jnp.ndarray) -> "HelmParams":
+        return HelmParams(a[0], a[1], a[2], a[3], a[4], a[5])
+
+
+# --------------------------------------------------------------------------
+# Spatial: Helmholtz kernel
+# --------------------------------------------------------------------------
+
+
+def _rbf_hess(S: jnp.ndarray, S2: jnp.ndarray, ls, var) -> jnp.ndarray:
+    """Mixed second derivatives of an RBF kernel.
+
+    Returns H with H[i, j, a, b] = d^2 / (d x_a d x'_b) k(S_i, S2_j), which for
+    k = var * exp(-|d|^2 / (2 l^2)), d = x - x', equals
+
+        k * (delta_ab / l^2 - d_a d_b / l^4).
+    """
+    d = S[:, None, :] - S2[None, :, :]  # (N, M, 2)
+    sq = jnp.sum(d**2, axis=-1)  # (N, M)
+    k = var * jnp.exp(-0.5 * sq / ls**2)  # (N, M)
+    eye = jnp.eye(2)
+    outer = d[..., :, None] * d[..., None, :]  # (N, M, 2, 2)
+    return k[..., None, None] * (eye / ls**2 - outer / ls**4)
+
+
+def k_helm(S: jnp.ndarray, S2: jnp.ndarray, p: HelmParams) -> jnp.ndarray:
+    """Helmholtz kernel (paper Sec. B.2), returned as (N, M, 2, 2).
+
+    F = grad(Phi) + rot(Psi) with rot(Psi) = (d_2 Psi, -d_1 Psi), so
+
+        K[0,0] = d^2_{x1 x1'} k_Phi + d^2_{x2 x2'} k_Psi
+        K[0,1] = d^2_{x1 x2'} k_Phi - d^2_{x2 x1'} k_Psi
+        K[1,0] = d^2_{x2 x1'} k_Phi - d^2_{x1 x2'} k_Psi
+        K[1,1] = d^2_{x2 x2'} k_Phi + d^2_{x1 x1'} k_Psi
+    """
+    A = _rbf_hess(S, S2, p.phi_ls, p.phi_var)  # potential
+    B = _rbf_hess(S, S2, p.psi_ls, p.psi_var)  # stream
+    k00 = A[..., 0, 0] + B[..., 1, 1]
+    k01 = A[..., 0, 1] - B[..., 1, 0]
+    k10 = A[..., 1, 0] - B[..., 0, 1]
+    k11 = A[..., 1, 1] + B[..., 0, 0]
+    return jnp.stack(
+        [jnp.stack([k00, k01], -1), jnp.stack([k10, k11], -1)], axis=-2
+    )  # (N, M, 2, 2)
+
+
+def k_helm_mat(S: jnp.ndarray, S2: jnp.ndarray, p: HelmParams) -> jnp.ndarray:
+    """Helmholtz Gram matrix flattened to (2N, 2M), point-major/component-minor."""
+    K = k_helm(S, S2, p)  # (N, M, 2, 2)
+    N, M = K.shape[0], K.shape[1]
+    return jnp.transpose(K, (0, 2, 1, 3)).reshape(2 * N, 2 * M)
+
+
+# --------------------------------------------------------------------------
+# Temporal: Matern-3/2 and its derivative blocks
+# --------------------------------------------------------------------------
+
+
+def matern32_blocks(t: jnp.ndarray, t2: jnp.ndarray, ls, var) -> jnp.ndarray:
+    """Matern-3/2 kernel and its t/t' derivatives, as (N, M, 2, 2).
+
+    With lam = sqrt(3)/l, tau = t - t':
+
+        M[0,0] = k            = var (1 + lam|tau|) exp(-lam|tau|)
+        M[0,1] = d_{t'} k     =  var lam^2 tau exp(-lam|tau|)
+        M[1,0] = d_{t} k      = -var lam^2 tau exp(-lam|tau|)
+        M[1,1] = d^2_{t t'} k =  var lam^2 (1 - lam|tau|) exp(-lam|tau|)
+
+    Note M[1,1] at tau=0 is var*lam^2 = 3 var / l^2 (= 3 for var=l=1), the value
+    the paper's Sec. H.2 flags as being silently zeroed by clipped-distance
+    autodiff implementations. It also equals P_inf[1,1] in the SPDE formulation
+    (spde.py), i.e. Var(d_t f) -- an internal consistency check of the two views.
+    """
+    lam = SQRT3 / ls
+    tau = t[:, None] - t2[None, :]
+    a = jnp.abs(tau)
+    e = jnp.exp(-lam * a)
+    k = var * (1.0 + lam * a) * e
+    dk = var * lam**2 * tau * e  # d_{t'} k
+    d2k = var * lam**2 * (1.0 - lam * a) * e
+    return jnp.stack(
+        [jnp.stack([k, dk], -1), jnp.stack([-dk, d2k], -1)], axis=-2
+    )  # (N, M, 2, 2)
+
+
+# --------------------------------------------------------------------------
+# Full temporal-Helmholtz kernel (plain and extended)
+# --------------------------------------------------------------------------
+
+
+def k_thelm_mat(
+    S: jnp.ndarray, t: jnp.ndarray, S2: jnp.ndarray, t2: jnp.ndarray, p: HelmParams
+) -> jnp.ndarray:
+    """Plain k_tHelm Gram matrix between (S,t) and (S2,t2). Shape (2N, 2M)."""
+    KS = k_helm(S, S2, p)  # (N, M, 2, 2)
+    kt = matern32_blocks(t, t2, p.time_ls, p.time_var)[..., 0, 0]  # (N, M)
+    K = KS * kt[..., None, None]
+    N, M = K.shape[0], K.shape[1]
+    return jnp.transpose(K, (0, 2, 1, 3)).reshape(2 * N, 2 * M)
+
+
+def k_ext_cross(
+    S: jnp.ndarray, t: jnp.ndarray, S2: jnp.ndarray, t2: jnp.ndarray, p: HelmParams
+) -> jnp.ndarray:
+    """Cov between plain observations at (S,t) and the *extended* state at (S2,t2).
+
+    Returns (2N, 4M): rows index (obs point, velocity component), columns index
+    (test point, velocity component, [f, d_t f]).
+    """
+    KS = k_helm(S, S2, p)  # (N, M, 2, 2)
+    Mt = matern32_blocks(t, t2, p.time_ls, p.time_var)  # (N, M, 2, 2)
+    # observation is the f-component (a=0); test keeps both b in {f, d_t f}
+    K = KS[..., :, :, None] * Mt[:, :, None, None, 0, :]  # (N, M, 2, 2, 2)
+    N, M = K.shape[0], K.shape[1]
+    # (N, c, M, c', b) -> (2N, 4M)
+    return jnp.transpose(K, (0, 2, 1, 3, 4)).reshape(2 * N, 4 * M)
+
+
+def k_ext_full(S: jnp.ndarray, t: jnp.ndarray, p: HelmParams) -> jnp.ndarray:
+    """Covariance of the extended state f = [f, d_t f]^T at (S,t). Shape (4N, 4N)."""
+    KS = k_helm(S, S, p)  # (N, N, 2, 2)
+    Mt = matern32_blocks(t, t, p.time_ls, p.time_var)  # (N, N, 2, 2)
+    K = KS[..., :, :, None, None] * Mt[:, :, None, None, :, :]  # (N,N,2,2,2,2)
+    N = K.shape[0]
+    # (i, c, a, j, c', b) -> (4N, 4N)
+    return jnp.transpose(K, (0, 2, 4, 1, 3, 5)).reshape(4 * N, 4 * N)

ballast/policies.py

@@ -0,0 +1,257 @@
+"""The six placement policies of paper Sec. H.3, and the BALLAST utility.
+
+UNIF, SOBOL, DIST-SEP, EIG, BALLAST-true, BALLAST-opt.
+"""
+
+from __future__ import annotations
+
+import functools
+
+import jax
+import jax.numpy as jnp
+import numpy as np
+from scipy.stats import qmc
+
+from .gp import base_factor, rank_q_logdet, posterior_ext_state, sample_ext_state
+from .kernels import HelmParams
+from .spde import SpdeOps, propagate
+from .trajectory import Grid, advect
+
+
+# --------------------------------------------------------------------------
+# Sampling posterior fields + projecting trajectories (Algorithm 2, steps 7-13)
+# --------------------------------------------------------------------------
+
+
+def sample_and_project(
+    key,
+    grid: Grid,
+    ops: SpdeOps,
+    ext_mean,
+    ext_chol,
+    exist_pos: jnp.ndarray,
+    t_m: float,
+    n_steps: int,
+    dt: float,
+    obs_every: int,
+):
+    """One BALLAST sample: draw f(R,t_m)|D_m, propagate to T, advect everything.
+
+    Particles are [all N_space candidate placements] ++ [existing drifters at
+    their current positions]. Returns positions/validity of both groups plus the
+    observation times.
+    """
+    ka, kb = jax.random.split(key)
+    X0 = sample_ext_state(ka, ext_mean, ext_chol, grid.n)
+    fields = propagate(X0, kb, ops, n_steps)  # (n_steps+1, N, 2)
+
+    s0 = jnp.concatenate([grid.R, exist_pos], axis=0)
+    active0 = jnp.ones(s0.shape[0], dtype=bool)
+    pos, valid, tidx = advect(grid, fields, s0, active0, dt, obs_every)
+    t_traj = t_m + tidx * dt
+    n_cand = grid.n
+    # Future observations land at cell centres (see Grid.snap): the utility must
+    # score the locations the drifter will actually report, not its exact path.
+    spos = grid.snap(pos)
+    return (
+        spos[:, :n_cand, :],
+        valid[:, :n_cand],
+        spos[:, n_cand:, :],
+        valid[:, n_cand:],
+        t_traj,
+        pos,
+    )
+
+
+def ballast_sample_utilities(
+    key,
+    grid: Grid,
+    ops: SpdeOps,
+    S_obs,
+    t_obs,
+    ext_mean,
+    ext_chol,
+    exist_pos,
+    t_m: float,
+    T: float,
+    dt: float,
+    obs_every: int,
+    p: HelmParams,
+    sigma: float,
+    n_samples: int,
+    chunk: int = 64,
+):
+    """Per-sample BALLAST utilities: returns (n_samples, N_space).
+
+    utils[j, i] = logdet(I + sigma^-2 K(X_m u P_j(s_exist) u P_j(R_i)))
+
+    Structured for the App. E.2 rank-q update: the base set X_m u P_j(s_exist)
+    does not depend on the candidate, so its Cholesky is computed once per
+    sample and reused across all N_space candidates. Averaging over j gives
+    eq. (5); keeping the per-sample axis is what makes the J-ablation of Sec. 5.1
+    computable from a single J=200 run.
+    """
+    n_steps = int(round((T - t_m) / dt))
+    keys = jax.random.split(key, n_samples)
+    out = []
+    for j in range(n_samples):
+        cpos, cval, epos, eval_, t_traj, _ = sample_and_project(
+            keys[j], grid, ops, ext_mean, ext_chol, exist_pos, t_m, n_steps, dt, obs_every
+        )
+        # base = past observations ++ projected trajectories of existing drifters
+        n_e = epos.shape[1]
+        S_base = jnp.concatenate([S_obs, epos.reshape(-1, 2)], axis=0)
+        t_base = jnp.concatenate(
+            [t_obs, jnp.repeat(t_traj[:, None], n_e, axis=1).reshape(-1)], axis=0
+        )
+        m_base = jnp.concatenate(
+            [jnp.ones(S_obs.shape[0], dtype=bool), eval_.reshape(-1)], axis=0
+        )
+        L, ld = base_factor(S_base, t_base, p, sigma, m_base)
+
+        def one(i):
+            return rank_q_logdet(
+                L, ld, S_base, t_base, m_base,
+                cpos[:, i, :], t_traj, cval[:, i], p, sigma,
+            )
+
+        vals = jnp.concatenate(
+            [jax.vmap(one)(jnp.arange(a, min(a + chunk, grid.n)))
+             for a in range(0, grid.n, chunk)]
+        )
+        out.append(vals)
+    return jnp.stack(out)
+
+
+def true_field_utilities(
+    grid: Grid,
+    true_fields: jnp.ndarray,
+    S_obs,
+    t_obs,
+    exist_pos,
+    t_m: float,
+    dt: float,
+    obs_every: int,
+    p: HelmParams,
+    sigma: float,
+    chunk: int = 64,
+):
+    """B(s; true): utilities with trajectories simulated in the ground-truth field.
+
+    Used only for the Gap_Full diagnostic of the Sec. G.1 ablation (and never by
+    any policy -- it is not implementable without knowing the true field).
+    `true_fields` must already be sliced to [t_m, T].
+    """
+    s0 = jnp.concatenate([grid.R, exist_pos], axis=0)
+    pos, valid, tidx = advect(
+        grid, true_fields, s0, jnp.ones(s0.shape[0], dtype=bool), dt, obs_every
+    )
+    t_traj = t_m + tidx * dt
+    n_cand = grid.n
+    pos = grid.snap(pos)  # observations are reported at cell centres
+    cpos, cval = pos[:, :n_cand, :], valid[:, :n_cand]
+    epos, eval_ = pos[:, n_cand:, :], valid[:, n_cand:]
+
+    n_e = epos.shape[1]
+    S_base = jnp.concatenate([S_obs, epos.reshape(-1, 2)], axis=0)
+    t_base = jnp.concatenate(
+        [t_obs, jnp.repeat(t_traj[:, None], n_e, axis=1).reshape(-1)], axis=0
+    )
+    m_base = jnp.concatenate(
+        [jnp.ones(S_obs.shape[0], dtype=bool), eval_.reshape(-1)], axis=0
+    )
+    L, ld = base_factor(S_base, t_base, p, sigma, m_base)
+
+    def one(i):
+        return rank_q_logdet(
+            L, ld, S_base, t_base, m_base, cpos[:, i, :], t_traj, cval[:, i], p, sigma
+        )
+
+    return jnp.concatenate(
+        [jax.vmap(one)(jnp.arange(a, min(a + chunk, grid.n)))
+         for a in range(0, grid.n, chunk)]
+    )
+
+
+# --------------------------------------------------------------------------
+# EIG (paper eq. 3): no look-ahead, only the initial placement location
+# --------------------------------------------------------------------------
+
+
+def eig_utilities(
+    grid: Grid, S_obs, t_obs, t_m: float, p: HelmParams, sigma: float, chunk: int = 128
+):
+    """logdet(I + sigma^-2 K(X_n u {(s, t_n)})) for every candidate s."""
+    L, ld = base_factor(S_obs, t_obs, p, sigma, None)
+    tv = jnp.array([t_m])
+
+    def one(i):
+        return rank_q_logdet(
+            L, ld, S_obs, t_obs, None,
+            grid.R[i][None, :], tv, jnp.ones(1, dtype=bool), p, sigma,
+        )
+
+    return jnp.concatenate(
+        [jax.vmap(one)(jnp.arange(a, min(a + chunk, grid.n)))
+         for a in range(0, grid.n, chunk)]
+    )
+
+
+# --------------------------------------------------------------------------
+# DIST-SEP (paper Sec. H.3, adapted from Chen et al. 2024b)
+# --------------------------------------------------------------------------
+
+
+def dist_sep_scores(
+    key,
+    grid: Grid,
+    ops: SpdeOps,
+    ext_mean,
+    ext_chol,
+    exist_pos,
+    S_obs,
+    t_m: float,
+    T: float,
+    dt: float,
+    obs_every: int,
+    n_samples: int,
+):
+    """Rank-average of (i) expected drifter path length and (ii) separation.
+
+    (i) total distance travelled, averaged over BALLAST posterior samples;
+    (ii) negative Euclidean distance to the closest existing observation
+    location. Both are converted to ranks and averaged, then maximised.
+    """
+    n_steps = int(round((T - t_m) / dt))
+    keys = jax.random.split(key, n_samples)
+    lengths = []
+    for j in range(n_samples):
+        _, cval, _, _, _, raw = sample_and_project(
+            keys[j], grid, ops, ext_mean, ext_chol, exist_pos, t_m, n_steps, dt, obs_every
+        )
+        # distance travelled uses the true (unsnapped) path
+        cpos = raw[:, : grid.n, :]
+        step = jnp.linalg.norm(cpos[1:] - cpos[:-1], axis=-1)  # (n_obs-1, N)
+        ok = cval[1:] & cval[:-1]
+        lengths.append(jnp.sum(jnp.where(ok, step, 0.0), axis=0))
+    length = jnp.mean(jnp.stack(lengths), axis=0)  # (N,)
+
+    d = jnp.linalg.norm(grid.R[:, None, :] - S_obs[None, :, :], axis=-1)
+    separation = -jnp.min(d, axis=1)  # negative distance to closest observation
+
+    r1 = jnp.argsort(jnp.argsort(length))
+    r2 = jnp.argsort(jnp.argsort(separation))
+    return 0.5 * (r1 + r2)
+
+
+# --------------------------------------------------------------------------
+# Space-filling designs
+# --------------------------------------------------------------------------
+
+
+def sobol_indices(grid: Grid, n: int, seed: int) -> np.ndarray:
+    """Scrambled Sobol points on [0,1)^2 mapped to grid cell indices (Sec. H.3)."""
+    pts = qmc.Sobol(d=2, scramble=True, seed=seed).random(n)
+    ix = np.clip((pts[:, 0] * grid.nx).astype(int), 0, grid.nx - 1)
+    iy = np.clip((pts[:, 1] * grid.ny).astype(int), 0, grid.ny - 1)
+    return ix * grid.ny + iy

ballast/spde.py

@@ -0,0 +1,119 @@
+"""SPDE / state-space formulation of the separable spatio-temporal GP (paper Sec. 4.1, App. F).
+
+For a separable kernel k = k_space(s,s') * k_time(t,t') with k_time Matern-3/2,
+the extended field f(R,t) = [f(R,t), d_t f(R,t)]^T solves the linear SPDE
+
+    d/dt f(R,t) = (I_space (x) F) f(R,t) + (I_space (x) L) w(t)
+
+driven by white noise with spectral density K_space (x) Q_c (paper F.2), giving
+the *exact* discrete-time transition
+
+    f_{k+1} = (I (x) Phi) f_k + e_k,   e_k ~ N(0, K_space (x) Q).
+
+Why the paper's sampling scheme is exact (this is the crux of Claim 2)
+---------------------------------------------------------------------
+The dynamics are *pointwise in space*: the SDE at location s is driven only by
+w(s, .) and never by the field at another location. Hence f(R, t > t_m) is a
+deterministic function of the extended state f(R, t_m) and the future noise
+{w(R, u) : u > t_m}, and that future noise is independent of everything at times
+<= t_m. So for observations D_m taken at times <= t_m -- even at *non-gridded*
+Lagrangian locations --
+
+    f(R, t > t_m)  _||_  D_m   |   f(R, t_m).
+
+Therefore drawing the initial condition f(R,t_m) | D_m from the extended dense GP
+posterior and propagating it with the SPDE gives exact posterior samples, while
+never filtering over the observation locations. `tests/test_spde.py` verifies
+this against a dense GP built over the full space-time test set.
+
+State layout: X has shape (2*N_space, 2). Rows are (location, velocity
+component) point-major/component-minor; columns are [f, d_t f].
+"""
+
+from __future__ import annotations
+
+from typing import NamedTuple
+
+import jax
+import jax.numpy as jnp
+
+from .kernels import SQRT3, HelmParams, k_helm_mat
+
+
+class SpdeOps(NamedTuple):
+    phi: jnp.ndarray  # (2, 2) one-step transition e^{F dt}
+    L_Q: jnp.ndarray  # (2, 2) chol of process noise Q
+    L_Pinf: jnp.ndarray  # (2, 2) chol of stationary covariance P_inf
+    L_space: jnp.ndarray  # (2N, 2N) chol of the spatial Helmholtz Gram
+
+
+def temporal_matrices(time_ls, time_var, dt: float):
+    """Phi = exp(F dt), Q = P_inf - Phi P_inf Phi^T, P_inf (paper F.1).
+
+    F = [[0, 1], [-lam^2, -2 lam]] with lam = sqrt(3)/l is -lam*I + N with N
+    nilpotent (N^2 = 0), so exp(F dt) = e^{-lam dt} (I + N dt) in closed form.
+    """
+    lam = SQRT3 / time_ls
+    e = jnp.exp(-lam * dt)
+    phi = e * jnp.array(
+        [[1.0 + lam * dt, dt], [-(lam**2) * dt, 1.0 - lam * dt]]
+    )
+    pinf = jnp.array([[time_var, 0.0], [0.0, lam**2 * time_var]])
+    q = pinf - phi @ pinf @ phi.T
+    return phi, q, pinf
+
+
+def make_ops(R: jnp.ndarray, p: HelmParams, dt: float, jitter: float = 1e-8) -> SpdeOps:
+    """Build the SPDE operators for spatial grid R (N, 2)."""
+    phi, q, pinf = temporal_matrices(p.time_ls, p.time_var, dt)
+    Ks = k_helm_mat(R, R, p)
+    Ks = Ks + jitter * jnp.eye(Ks.shape[0])
+    return SpdeOps(
+        phi=phi,
+        L_Q=jnp.linalg.cholesky(q + jitter * jnp.eye(2)),
+        L_Pinf=jnp.linalg.cholesky(pinf),
+        L_space=jnp.linalg.cholesky(Ks),
+    )
+
+
+def _step(X, key, ops):
+    """One exact transition: X <- X Phi^T + L_space Z L_Q^T.
+
+    Cov(E_ia, E_jb) = (L_space L_space^T)_ij (L_Q L_Q^T)_ab = K_space_ij Q_ab,
+    i.e. vec(E) ~ N(0, K_space (x) Q) as required (App. E.1 Kronecker Cholesky).
+    """
+    Z = jax.random.normal(key, X.shape, dtype=X.dtype)
+    return X @ ops.phi.T + ops.L_space @ Z @ ops.L_Q.T
+
+
+def propagate(X0: jnp.ndarray, key, ops: SpdeOps, n_steps: int) -> jnp.ndarray:
+    """Propagate an extended state n_steps times.
+
+    Returns the *velocity* field history of shape (n_steps + 1, N, 2), i.e. only
+    the f-component of the extended state at each step (including the initial).
+    """
+    keys = jax.random.split(key, n_steps)
+
+    def body(X, k):
+        Xn = _step(X, k, ops)
+        return Xn, Xn[:, 0]
+
+    _, hist = jax.lax.scan(body, X0, keys)
+    out = jnp.concatenate([X0[None, :, 0], hist], axis=0)  # (n_steps+1, 2N)
+    return out.reshape(n_steps + 1, -1, 2)
+
+
+def prior_sample(key, R: jnp.ndarray, ops: SpdeOps, n_steps: int) -> jnp.ndarray:
+    """Exact prior sample of the temporal Helmholtz GP on R over a time grid.
+
+    Starts from the stationary distribution f(R,0) ~ N(0, K_space (x) P_inf) and
+    propagates. Cost is O((2 N_space)^2 N_t) (paper F.4) versus O((2 N_space
+    N_t)^3) for a dense draw -- this is what makes generating the 25x25x1001
+    synthetic ground-truth fields of Sec. 5.2 tractable at all.
+
+    Returns velocity fields (n_steps + 1, N, 2).
+    """
+    k0, k1 = jax.random.split(key)
+    Z = jax.random.normal(k0, (ops.L_space.shape[0], 2), dtype=R.dtype)
+    X0 = ops.L_space @ Z @ ops.L_Pinf.T
+    return propagate(X0, k1, ops, n_steps)

ballast/trajectory.py

@@ -0,0 +1,138 @@
+"""Lagrangian observer advection and observation model (paper Sec. H.1).
+
+An observer released at (s, t) is advected by Euler discretisation
+
+    s_{n+1} = s_n + delta_t V(s_n, t_n),   t_{n+1} = t_n + delta_t
+
+with delta_t = 0.01. The field is only known on the spatial grid, so V(s, t) is
+piecewise constant over grid cells ("the velocity at a spatial location will be
+that of the grid cell containing the location"). The observer is terminated as
+soon as it leaves the region. Observations are taken every delta_obs = 0.05 with
+i.i.d. N(0, 0.1^2) noise.
+
+Everything is batched over particles and written for fixed shapes: a particle
+that has left the region is frozen and flagged invalid, and downstream Gram
+matrices mask it out (see gp.noise_gram).
+"""
+
+from __future__ import annotations
+
+import jax
+import jax.numpy as jnp
+
+
+class Grid:
+    """Regular (or mildly uneven) rectangular grid with piecewise-constant lookup.
+
+    Cell centres are R = outer product of `xs` and `ys` in row-major order
+    (index = ix * ny + iy), matching the spatial layout used everywhere else.
+    """
+
+    def __init__(self, xs: jnp.ndarray, ys: jnp.ndarray):
+        self.xs = jnp.asarray(xs)
+        self.ys = jnp.asarray(ys)
+        self.nx = self.xs.shape[0]
+        self.ny = self.ys.shape[0]
+        self.n = self.nx * self.ny
+        # cell edges: midpoints between centres, extended to the outer half-cells
+        self.x_edges = self._edges(self.xs)
+        self.y_edges = self._edges(self.ys)
+        X, Y = jnp.meshgrid(self.xs, self.ys, indexing="ij")
+        self.R = jnp.stack([X.reshape(-1), Y.reshape(-1)], axis=-1)  # (n, 2)
+
+    @staticmethod
+    def _edges(c: jnp.ndarray) -> jnp.ndarray:
+        mid = 0.5 * (c[1:] + c[:-1])
+        lo = c[0] - (mid[0] - c[0])
+        hi = c[-1] + (c[-1] - mid[-1])
+        return jnp.concatenate([jnp.array([lo]), mid, jnp.array([hi])])
+
+    def inside(self, s: jnp.ndarray) -> jnp.ndarray:
+        """(..., 2) -> (...) bool: is the point within the region's outer edges?"""
+        return (
+            (s[..., 0] >= self.x_edges[0])
+            & (s[..., 0] <= self.x_edges[-1])
+            & (s[..., 1] >= self.y_edges[0])
+            & (s[..., 1] <= self.y_edges[-1])
+        )
+
+    def cell_index(self, s: jnp.ndarray) -> jnp.ndarray:
+        """(..., 2) -> (...) flat index of the containing cell (clipped at borders)."""
+        ix = jnp.clip(jnp.searchsorted(self.x_edges, s[..., 0]) - 1, 0, self.nx - 1)
+        iy = jnp.clip(jnp.searchsorted(self.y_edges, s[..., 1]) - 1, 0, self.ny - 1)
+        return ix * self.ny + iy
+
+    def lookup(self, field: jnp.ndarray, s: jnp.ndarray) -> jnp.ndarray:
+        """field (n, 2) at points s (..., 2) -> (..., 2), piecewise constant."""
+        return field[self.cell_index(s)]
+
+    def snap(self, s: jnp.ndarray) -> jnp.ndarray:
+        """Snap points to the centre of their containing cell.
+
+        The ground-truth field exists only on the grid, and a drifter measures
+        "the velocity of the grid cell containing the location" (paper Sec. H.1).
+        That measurement is therefore a noisy observation of f at the *cell
+        centre*, and is what the GP must be conditioned on.
+
+        Regressing it at the drifter's exact position instead is misspecified:
+        for the Sec. 5.2 setup the within-cell field variation has sd ~0.29
+        (cell 0.167 wide vs stream lengthscale 0.5), i.e. ~3x the assumed
+        sigma_obs = 0.1. Feeding that mismatch to a GP that believes the noise is
+        0.1 makes it interpolate discretisation error: the posterior mean
+        overshoots to ~3x the true field range and the field error rises above
+        the prior as drifters are added. Snapping removes the misspecification
+        exactly and restores the expected monotone error decay.
+        """
+        return self.R[self.cell_index(s)]
+
+
+def advect(
+    grid: Grid,
+    fields: jnp.ndarray,
+    s0: jnp.ndarray,
+    active0: jnp.ndarray,
+    dt: float,
+    obs_every: int,
+):
+    """Advect particles through a time-varying field and record observations.
+
+    Parameters
+    ----------
+    fields : (n_steps + 1, n_cells, 2) velocity field history, fields[k] is the
+        field at time t_start + k*dt.
+    s0 : (P, 2) initial positions.
+    active0 : (P,) bool, whether each particle exists at all.
+
+    Returns
+    -------
+    pos : (n_obs, P, 2) observation positions, n_obs = n_steps // obs_every
+    valid : (n_obs, P) bool, observation is inside the region and the particle
+        had not yet left
+    tidx : (n_obs,) int, step index of each observation
+
+    Observations are recorded at steps obs_every, 2*obs_every, ... The release
+    instant itself is not an observation; the first measurement is one
+    observation interval after deployment.
+    """
+    n_steps = fields.shape[0] - 1
+
+    def body(carry, k):
+        s, alive = carry
+        v = grid.lookup(fields[k], s)
+        s_new = jnp.where(alive[:, None], s + dt * v, s)
+        alive_new = alive & grid.inside(s_new)
+        return (s_new, alive_new), (s_new, alive_new)
+
+    (_, _), (traj, alive_hist) = jax.lax.scan(
+        body, (s0, active0 & grid.inside(s0)), jnp.arange(n_steps)
+    )
+    # traj[k] is the position after step k+1, i.e. at time t_start + (k+1)*dt
+    sel = jnp.arange(obs_every - 1, n_steps, obs_every)
+    return traj[sel], alive_hist[sel], sel + 1
+
+
+def observe(key, grid: Grid, fields: jnp.ndarray, pos, valid, tidx, noise_sd: float):
+    """Sample noisy velocity measurements at the recorded observation points."""
+    v = jax.vmap(lambda f, s: grid.lookup(f, s))(fields[tidx], pos)
+    eps = noise_sd * jax.random.normal(key, v.shape, dtype=v.dtype)
+    return jnp.where(valid[..., None], v + eps, 0.0)