# Adjoint-Weak Fractional Residuals

- ID: 2212
- Canonical URL: https://synthcore.org/idea/2212/adjoint-weak-fractional-residuals
- API JSON: https://synthcore.org/api/idea/2212.json
- API Markdown: https://synthcore.org/api/idea/2212.md
- Verification status: mech_ok_no_baseline
- Source: [arXiv:2608.12879](https://arxiv.org/abs/2608.12879)
- Category: training
- Solves: stability, accuracy, sample-efficiency
- ML areas: training, loss, world-model
- Math tags: fractional-analysis, functional-analysis, numerical-analysis
- Ratings: usefulness 7/10; difficulty 4/10; novelty 5/10

## Idea description

Replace pointwise fractional derivatives of noisy trajectories in a neural PDE or neural dynamics loss with weak projections in which the fractional operator acts on smooth test functions. The network is trained to match integral residuals over local space-time windows, making the residual insensitive to high-frequency measurement noise while retaining sensitivity to the underlying fractional dynamics.

## Mathematical statement

The construction uses the fractional integration-by-parts or adjoint identity: for a sufficiently smooth test function phi with boundary terms eliminated, the integral of phi(z) times the left Riemann-Liouville derivative of f equals the integral of f(z) times the right adjoint fractional derivative of phi. Here D_{a+}^alpha is the left fractional derivative of order alpha on [a,b], D_{b-}^alpha is its right adjoint, f is the observed or predicted field, and phi is a compactly supported smooth test function. For a neural PDE u_theta(t,x), define a weak residual by integrating each candidate equation term against phi_j and moving derivatives from noisy u to analytically or numerically precomputed derivatives of phi_j. The smoothing asset is that the resulting feature is an integral against a fixed smooth kernel: for independent zero-mean grid noise epsilon_i with variance sigma^2, its variance is sigma^2 times the squared norm of the quadrature weights, rather than the amplified variance produced by pointwise fractional differentiation.

## Key formulas

- $$\int_a^b \phi(z)\,({}_{a}D_{z}^{\alpha}f)(z)\,dz = \int_a^b f(z)\,({}_{z}D_{b}^{\alpha}\phi)(z)\,dz$$
- $$W_{j,\alpha}^{t}[u]=\int_{0}^{T}\!\int_{\Omega} \phi_j(t,x)\,\mathcal{T}_{\alpha}u(t,x)\,dx\,dt=\int_{0}^{T}\!\int_{\Omega}u(t,x)\,\mathcal{T}_{\alpha}^{*}\phi_j(t,x)\,dx\,dt$$
- $$R_j(\theta)=W_{j,\alpha}^{t}[u_\theta]-c_xW_{j,\beta}^{x}[u_\theta]-c_0W_j[u_\theta]-W_j[F_\theta],\qquad \mathcal{L}_{\mathrm{weak}}(\theta)=\frac{1}{J}\sum_{j=1}^{J}R_j(\theta)^2+\lambda\|\theta\|_2^2$$
- $$\operatorname{Var}\!\left[\sum_i q_i\varepsilon_i\right]=\sigma^2\sum_iq_i^2$$

## Implementation notes

(1) Integration point: modify the loss of a PINN, neural operator, or neural ODE/world model that predicts u_theta(t,x). Do not compute fractional derivatives of noisy training observations with automatic differentiation. Instead, use local space-time patches and fixed smooth test functions phi_j, such as compactly supported cubic B-splines or Gaussian bumps, with J functions per minibatch. For each fractional order alpha or beta, precompute T_alpha^* phi_j and X_beta^* phi_j on the quadrature grid. (2) Pseudocode: sample a minibatch of windows Q_b and quadrature points (t_i,x_i); evaluate y_i=u_theta(t_i,x_i); for every test function j compute w_time[j]=sum_i y_i*(T_alpha_star_phi[j])[i]*quadrature_weight[i]; compute w_space[j] analogously; compute w_source[j]=sum_i F_theta(t_i,x_i)*phi_j[i]*quadrature_weight[i]; set residual[j]=w_time[j]-c_x*w_space[j]-c_0*w_identity[j]-w_source[j]; backpropagate mean(residual**2) plus the ordinary data-fit loss. The adjoint identity determines the precomputed kernels and the displayed residual equation determines the loss. (3) Compute the adjoint fractional derivative of each phi_j analytically or with high-order quadrature; estimate no derivative from noisy labels. Tune window size, test-function width, and the weak/data-loss mixing coefficient on a validation set. Use several alpha values if the order is unknown, but initially fix alpha to the ground-truth order to isolate robustness. (4) First experiment: train a small MLP PINN on one-dimensional fractional advection-diffusion or Burgers trajectories with 1%, 5%, and 10% multiplicative Gaussian noise. Compare strong-form autodiff residuals against weak residuals using the same network, optimizer, collocation points, and FLOPs. Measure held-out trajectory error, residual variance across noise seeds, and convergence failures. Success is lower validation error and a smoother loss curve at larger alpha and noise, with weak-feature variance decreasing when quadrature resolution is doubled.

## Verification

- Status: mech_ok_no_baseline
- Mechanism evidence: yes
- Mechanism confirmed: yes
- Practical verdict: no_effect
- Verdict: Built `experiment.py`, which uses a Grünwald fractional-derivative matrix and its exact weighted transpose as the adjoint weak kernel. The discrete integration-by-parts identity held to relative error 4.84e-16; weak noise variance was proportional to sigma^2 with coefficient 0.01056–0.01139. Under each grid doubling, weak squared kernel norm ratios were 0.503–0.506 versus the predicted 0.5, while strong pointwise derivative norms grew by 3.031 versus the predicted 2^(2*0.8)=3.031. In the matched coefficient toy, weak noise-induced RMSE was 20.1x, 23.8x, 26.0x, and 47.4x lower than the strong estimate for sigma 0.01, 0.03, 0.1, and 0.3, respectively; the mechanism is therefore a real observed win in this setting.

### Mechanism check

- Verdict: Built `experiment.py`, which uses a Grünwald fractional-derivative matrix and its exact weighted transpose as the adjoint weak kernel. The discrete integration-by-parts identity held to relative error 4.84e-16; weak noise variance was proportional to sigma^2 with coefficient 0.01056–0.01139. Under each grid doubling, weak squared kernel norm ratios were 0.503–0.506 versus the predicted 0.5, while strong pointwise derivative norms grew by 3.031 versus the predicted 2^(2*0.8)=3.031. In the matched coefficient toy, weak noise-induced RMSE was 20.1x, 23.8x, 26.0x, and 47.4x lower than the strong estimate for sigma 0.01, 0.03, 0.1, and 0.3, respectively; the mechanism is therefore a real observed win in this setting.
- Confidence: 9/10
- Limitations: No neural network was trained and no fractional PDE trajectory benchmark, data-fit tradeoff, FLOP comparison, validation trajectory error, GPU execution, or convergence study was tested. The strong-resolution scaling is specific to the implemented Grünwald discretization, and the coefficient experiment compares noise-induced error relative to each method's own noiseless estimate rather than absolute model-identification bias.

### Practical benchmark

- Paired seeds: 8
- Baseline mean: 0
- Idea mean: 0
- p-value: 0.52365
- Paired wins: 5/8
- Benchmark verdict: no measurable effect

## Artifacts

- [bench_report.json](https://synthcore.org/code/880/bench_report.json)
- [experiment.py](https://synthcore.org/code/880/experiment.py)
- [report.md](https://synthcore.org/code/880/report.md)
- [report_bench_2026-09-01T132726.md](https://synthcore.org/code/880/report_bench_2026-09-01T132726.md)
- [results.json](https://synthcore.org/code/880/results.json)
- [stage2_bench.py](https://synthcore.org/code/880/stage2_bench.py)
- [Download all files as ZIP](https://synthcore.org/download/880)

## Disclaimer

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