✗ Failed on benchmark 2026

Normal-Cone Certified Priority Weighting

Implementation & benchmark of arXiv:2608.12520 — Weight Certificates for Convex Multi-Objective MPC: Geometric Characterization, $\ell^1$ Construction, and $\ell^2$ Foreclosure

Usefulness7/10

Difficulty6/10

Novelty6/10

Optimization Accuracy Stability Sample efficiency Loss Optimizer Training Convex analysis Optimization Geometry

Source paper: Weight Certificates for Convex Multi-Objective MPC: Geometric Characterization, $\ell^1$ Construction, and $\ell^2$ Foreclosure arXiv:2608.12520 ⓘ · analyzed Sep 1, 2026

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

Idea description

Replace hand-tuned exponentially separated coefficients for multiple neural objectives with weights obtained from a local KKT certificate. For L1 hinge penalties, solve a small linear program that maximizes the smallest tier weight while enforcing approximate stationarity of the weighted objective at the current priority solution. This should preserve high-priority behavior more reliably than fixed loss weights while avoiding unnecessarily large coefficients.

Formulas

$$V_i(z)=\sum_j[g_{i,j}(z)]_+,\qquad [a]_+=\max(a,0),\qquad \min_{z\in X}\;J(z)+\sum_{i=1}^{L}w_iV_i(z).$$

$$\mathcal{A}=\{(v_1,\ldots,v_L,j):\exists z\in X,\ v_i\ge V_i(z),\ j\ge J(z)\},\qquad (w_1,\ldots,w_L,1)\in N_{\mathcal{A}}(V(z^*),J(z^*)).$$

$$0=\nabla J(z^*)+\sum_{i=1}^{L}w_i s_i+G_c(z^*)^T\lambda,\qquad s_i\in\partial V_i(z^*),\quad \lambda\ge0.$$$

$$\max_{w,\lambda,\delta}\ \delta\quad\text{s.t.}\quad w_i\ge\delta,\ 0\le w_i\le w_{\max},\ \left\|\nabla J+\sum_iw_is_i+G_c^T\lambda\right\|_\infty\le\epsilon,\ \lambda\ge0.$$$

Mathematical statement

Let z be the model output or decision vector, X be a convex feasible set, V_i(z)=sum_j[g_{i,j}(z)]_+ be the L1 hinge violation for priority tier i, and J(z) be the performance loss. The lexicographic solution z^* first minimizes V_1, then V_2, through V_L, and finally J. Define the upper achievement image A={(v_1,...,v_L,j): there exists z in X with v_i>=V_i(z) and j>=J(z)}. The geometric criterion is that a scalar weighted objective exactly supports the lexicographic point when (w_1,...,w_L,1) belongs to the outward normal cone N_A(V_1(z^*),...,V_L(z^*),J(z^*)). For convex differentiable pieces, a KKT certificate requires 0=gradient J(z^*)+sum_i w_i s_i+G_c(z^*)^T lambda, where s_i belongs to the subdifferential of V_i, G_c is the Jacobian of active constraints c(z)<=0, and lambda>=0. For each hinge term, s_{i,j}=0 when g_{i,j}<0, s_{i,j}=gradient g_{i,j} when g_{i,j}>0, and s_{i,j}=alpha gradient g_{i,j}, alpha in [0,1], at g_{i,j}=0. Use a slackened LP to maximize a positive weight margin delta while bounding the stationarity residual by epsilon.

Implementation notes

First integrate this as a loss-weight controller for a neural network with ordered objectives, such as safety, legality, reconstruction, calibration, or auxiliary-task penalties. The network produces predictions y; each tier computes differentiable constraint scores g_{i,j}(y), and the training loss is J(y)+sum_i w_i V_i(y). Begin with a convex last layer or frozen network features so the certificate assumptions are testable, then evaluate the local heuristic in the full network. Every K minibatches, compute the hinge masks, per-tier gradients s_i=gradient(V_i, parameters), and q=gradient(J, parameters). If there are explicit output constraints c(z)<=0, compute their Jacobian G_c and include nonnegative multipliers lambda. Solve the LP maximizing delta subject to w_i>=delta, 0<=w_i<=w_max, lambda>=0, and infinity-norm residual ||q+sum_i w_i s_i+G_c^T lambda||<=epsilon. If delta exceeds delta_min, replace the current weights by the LP solution; otherwise retain the previous weights or invoke sequential tier updates. Compute subgradients and the stationarity residual from the paper's mathematics. Estimate epsilon, w_max, delta_min, and the refresh interval on a validation split. Start with a small MLP on synthetic regression with three ordered constraints, comparing equal weights, fixed 100:10:1 weights, GradNorm, and the certificate controller. Measure tier violations at matched J, frequency of high-tier regressions, weight oscillation, and loss descent at equal FLOPs. Success means lower high-tier violations at equal performance and a positive certificate margin on most batches.

Verification

Failed on benchmark

Stage 1 · Toy mechanism gate: Passed ✓

Stage 2 · Mechanism transferred to benchmark: Not reproduced ✗

Stage 2 · Practical benchmark result: Inconclusive

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

Stage 1 — Mechanism check agent confidence 7/10

Built a readable LP-based normal-cone certificate controller and deterministic convex priority-training toy in experiment.py. All three quantitative mechanism predictions were confirmed: inverse-lambda scaling had maximum relative error 1.0e-9, the epsilon=1 feasibility transition was correct at every tested point, and slack-margin scaling had zero absolute error. In the conflicting training toy, the certificate matched equal weighting rather than improving it; fixed 100:10:1 achieved zero violation but at much higher performance loss, so no practical win was demonstrated.

Agent confidence: 7/10

Baseline: Equal weights: final J=0.5503883, total violation=0.0657977, tier-1 violation=0.0313366. Fixed 100:10:1: J=14.2530128, total violation=0, tier-1 violation=0.
Idea: Certificate controller: final J=0.5503883, total violation=0.0657977, tier-1 violation=0.0313366; identical to equal weighting. Mechanism checks: lambda-scaling maximum relative error=1.0e-9, feasibility transition 5/5 correct, slack-margin maximum absolute error=0.

Limitations: This is a tiny hand-designed convex last-layer problem, not a neural network or minibatch experiment. No GradNorm comparison, explicit constraint multipliers, validation hyperparameter tuning, FLOP/speed measurement, stochastic training, or larger multi-dimensional hinge geometry was tested. The positive result supports the LP mechanism, not a broad empirical superiority claim.

How to run: python3 experiment.py

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

Ahead of the baseline (-0.3663 metric points) but not statistically significant (p=0.2116, wins 5 / 0 paired seeds).

Benchmark: Tabular regression (Friedman)
Model: mlp_tiny
Paired seeds: 8
Baseline mean: 0
Idea mean: 11.053
Effect (Δ): -0.3663 (n/a; negative = idea better)
Wins: 5 / 0 paired seeds
p-value: 0.2116 (permutation test, 20 000 shuffles)
Smallest detectable effect: n/a
Mechanism: Not confirmed ✗
Practical effect: Inconclusive
Baseline tuning: swept over 0 configs

Limitations:

Only tabular/Friedman regression with mlp_tiny was tested; no explicit feasible-set multipliers, GradNorm, FLOP measurement, or other tracks were evaluated.

How to run: python3 stage2_certified_priority.py

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

Stage 2 — Benchmark Sep 1, 2026 latest Failed ✗

Agent confidence: 9/10

Implemented the LP-based normal-cone certificate controller on the matched tabular Friedman regression track with mlp_tiny. Mean test MSE improved from 11.4192 to 11.0530, but the paired permutation test was not significant (p=0.2116), and the trained-network mechanism signature was not confirmed.

Baseline: lr=0.01, ratio=[100,10,1], mean MSE=11.4192293, std=1.3400197
Delta mean: -0.3662738
Idea: best shared-grid certificate result, mean MSE=11.0529555, std=1.1602236
Idea wins: 5
Math check: passed; LP weights [2.999999999,1.000000001], residual 1.0e-9
Mechanism signature: predicted epsilon=0.02, observed residual=infinity, positive margin frequency=0, confirmed=false
N pairs: 8
P value: 0.2116

Benchmark result