Beckmann Flow Boundary Regularizer
Implementation & benchmark of arXiv:2606.31961 — A Beckmann boundary form of Talagrand's conjecture on the discrete cube
Source paper: A Beckmann boundary form of Talagrand's conjecture on the discrete cube arXiv:2606.31961 ⓘ · analyzed Aug 29, 2026
AI-generated research hypothesis, automatically tested. Not peer-reviewed.
Idea description
Regularize a classifier on binary or categorical-product inputs with the minimum-norm discrete flow whose divergence matches the model's cube Laplacian. Unlike a direct edge-sensitivity penalty, the flow can route mass nonlocally and combine coordinate changes through an L2 norm, potentially preserving useful interactions while suppressing unstable decision boundaries. The regularizer should be applied to logits or probabilities and combined with the supervised loss, not used alone.
Formulas
Mathematical statement
For the discrete cube \(\Omega_n=\{-1,1\}^n\), define \(D_i f(x)=(f(x)-f(x^{\oplus i}))/2\) and \(L f=\sum_i D_i f\), where \(x^{\oplus i}\) flips coordinate \(i\). A vector field is \(V(x)=(V_1(x),\ldots,V_n(x))\), with divergence \(\operatorname{div}V(x)=\sum_i(V_i(x)-V_i(x^{\oplus i}))\). The Beckmann boundary is \(\mathsf{B}(f)=\inf_{\operatorname{div}V=Lf}\mathbb{E}_x\|V(x)\|_2\). The constraint is linear, while the objective is an expected group-L2 norm, so it is a finite-dimensional convex program. The paper proves, for nonconstant Boolean \(f\), \(\mathsf{B}(f)\gtrsim \operatorname{Var}(f)\sqrt{\log(1+1/\sum_i\operatorname{Inf}_i(f)^2)}\), where \(\operatorname{Inf}_i(f)=\Pr[f(x)\neq f(x^{\oplus i})]\). In the neural adaptation, \(f\) is a scalar logit or probability function on sampled cube points, and the convex program is unrolled or approximately solved.
Implementation notes
Integrate this at the loss level for a model whose input contains n binary features, bits, or a small discrete latent code. For each minibatch point x, evaluate the scalar logit f_theta(x), all one-bit neighbors f_theta(x^{\oplus i}), and therefore b(x)=Lf_theta(x). Maintain a small vector field V_i(x) for the sampled cube points. Solve the convex approximation min_V (1/|B|) sum_x sqrt(sum_i V_i(x)^2+epsilon) subject to div V(x)=b(x). A practical MVP uses 10-30 projected primal-dual iterations: initialize V=0 and dual variable u=0; update u <- u + eta_u(div(V)-b); update V <- V - eta_V grad_V[<u,div(V)> + lambda_V sum_x sqrt(||V(x)||_2^2+epsilon)]; then optionally project each local vector onto the corresponding L2 ball. Cache neighbor indices so the divergence is a sparse gather/scatter operation. During early experiments, use a penalty on constraint residual plus the group norm, rather than requiring exact feasibility: R_B=(1/|B|)sum_x sqrt(||V(x)||_2^2+epsilon)+rho(div(V)-b)^2. Add lambda_B R_B to cross-entropy. The mathematical object computed exactly is the discrete Laplacian target b and the flow objective; the finite-batch flow and primal-dual iterate are empirical approximations. First test on a 10-20 dimensional synthetic parity-plus-noise task and a tabular binary UCI dataset, comparing cross-entropy plus ordinary edge-sensitivity against cross-entropy plus Beckmann regularization at matched FLOPs. Measure test accuracy, prediction changes under one-bit and multi-bit perturbations, flow constraint residual, and loss curvature. Success is lower multi-bit adversarial sensitivity or improved test accuracy at equal one-bit sensitivity, without a large training-time increase.
Verification
Stage 1 · Toy mechanism gate: Failed ✗
Stage 2 · Mechanism transferred to benchmark: Not tested
Stage 2 · Practical benchmark result: Not run
Methodology: Toy-system gate first; the benchmark stage runs only after a pass. How verification works
Stage 1 — Mechanism check agent confidence 9/10
Built a runnable Beckmann-flow MVP with exact cube Laplacian/divergence operators, an unrolled penalized flow solver, and a parity classification comparison against cross-entropy and edge-sensitivity regularization. The mathematical checks passed: divergence/Laplacian means were near zero, the adjoint identity error was 2.3e-7, an explicit feasible flow had zero residual, and the solver reduced the penalized objective from 5.78 to 0.495 with residual/target RMS 0.052. The learning result was not a win: Beckmann reached 99.2% accuracy and 1-bit change 3.91 versus the edge baseline’s 85.9% and 1.79, while its 2-bit change was higher (1.70 versus 1.30), so the claimed stability benefit was not observed.
- Agent confidence
- 9/10
- Baseline
- CE: accuracy 1.000, one-bit logit change 6.462, two-bit change 0.578, train CE 0.00025; edge: accuracy 0.859, one-bit change 1.792, two-bit change 1.295, train CE 0.0813
- Idea
- Beckmann: accuracy 0.992, one-bit logit change 3.910, two-bit change 1.699, train CE 0.00658, flow residual RMS 0.0885, target RMS 13.25
Limitations: Only one small synthetic 8-bit parity experiment and one random seed were tested; no tabular/UCI dataset, hyperparameter sweep, matched-FLOP timing, curvature measurement, minibatch approximation, or multi-seed statistical analysis was performed.
How to run: python3 beckmann_mvp.py
Verdict computed by deterministic test code from paired-seed statistics — not by the language model.
Artifacts
- beckmann_mvp.py 5.8 KB View Raw
- report.md 1.6 KB View
- results.json 1.2 KB View Raw