✓✓ Beats tuned baseline 2026

Minkowski-Additive Convex Latents

Implementation & benchmark of arXiv:2608.26615 — Galerkin approximations to the space of convex bodies by polytopes in nondegenerate V-representation

Usefulness6/10

Difficulty4/10

Novelty8/10

Architecture Stability Generalization Scalability World model Graph nn Regularization Training dynamics Convex analysis Geometry Metric geometry

Source paper: Galerkin approximations to the space of convex bodies by polytopes in nondegenerate V-representation arXiv:2608.26615 ⓘ · analyzed Aug 29, 2026

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

Idea description

Store a convex object as a direction-indexed vertex tuple and implement composition of objects through componentwise Minkowski addition and nonnegative scaling. This creates a structured residual or compositional layer where convexification is nonexpansive, making perturbation amplification controllable and avoiding repeated generic geometric optimization.

Formulas

$$\pi^{\flat}_{\boldsymbol{a}}(K):=\{\boldsymbol{x}\in\mathbb{R}^{d\times N}:x_i\in\arg\max_{x\in K}a_i^T x\ \text{for all }i\},$$

$$\pi^{\flat}_{\boldsymbol{a}}(K+L)=\pi^{\flat}_{\boldsymbol{a}}(K)+\pi^{\flat}_{\boldsymbol{a}}(L),\qquad \pi^{\flat}_{\boldsymbol{a}}(\lambda K)=\lambda\pi^{\flat}_{\boldsymbol{a}}(K),\quad \lambda\geq0,$$

$$\operatorname{dist}(\operatorname{co}\{\boldsymbol{x}\},\operatorname{co}\{\boldsymbol{y}\})\leq\operatorname{dist}(\{\boldsymbol{x}\},\{\boldsymbol{y}\}),$$

$$\boldsymbol{z}=\alpha\boldsymbol{x}+\beta\boldsymbol{y},\quad z_i=\alpha x_i+\beta y_i,\quad P_{\mathrm{out}}=\operatorname{co}\{z_1,\ldots,z_N\},\qquad \alpha,\beta\geq0.$$

Mathematical statement

For a compact convex set K, define the multivalued directional projector $\pi^{\flat}_{\boldsymbol{a}}(K)=\{\boldsymbol{x}:x_i\in\arg\max_{x\in K}a_i^T x\ \text{for all }i\}$, where a_i are fixed directions. Lemma 29 gives exact compatibility with Minkowski addition and nonnegative scaling: $\pi^{\flat}_{\boldsymbol{a}}(K+L)=\pi^{\flat}_{\boldsymbol{a}}(K)+\pi^{\flat}_{\boldsymbol{a}}(L)$ and $\pi^{\flat}_{\boldsymbol{a}}(\lambda K)=\lambda\pi^{\flat}_{\boldsymbol{a}}(K)$, with tuple operations componentwise. Thus if x_i and y_i are selected directional support maximizers, x_i plus y_i represents the corresponding support maximizer of K plus L. The decoded set is $P(\boldsymbol{x})=\operatorname{co}\{x_i\}$. Lemma 6 states that convexification is 1-Lipschitz: perturbing the point tuple cannot increase the induced directed set distance beyond the tuple perturbation. Arbitrary compositions can reach the boundary of the cone, so the implementation should use a strict margin or a projection step.

Implementation notes

1. Integration point: add a structured convex-object composition block to a world model, relational graph network, or diffusion denoiser that combines multiple predicted convex regions. Represent each object by a tensor X with shape batch by N by d, where N indexes fixed directions and d indexes coordinates. 2. Pseudocode: encode objects as X and Y; predict nonnegative mixture weights alpha and beta using softplus of two scalar network outputs; form z_i equal to alpha times x_i plus beta times y_i for every direction i; apply one or more projected-gradient steps toward the constraints a_i transpose z_i minus a_i transpose z_j at least epsilon; decode with a convex-hull layer or support queries. Add a cone-margin penalty consisting of the sum over i not equal to j of max(0, epsilon minus a_i transpose z_i plus a_i transpose z_j) squared. 3. The paper supplies the exact Minkowski and scaling rules and the nonexpansive convexification guarantee. Estimate empirical error amplification by perturbing X and Y, measuring the maximum tuple perturbation, and comparing it with the Hausdorff distance between decoded outputs. Do not assume uniqueness on the cone boundary. 4. First experiment: compose pairs of random two-dimensional and three-dimensional convex polygons, train a small predictor to match their Minkowski sum, and compare this block with a generic MLP followed by convex-hull decoding. Evaluate Hausdorff error, runtime, gradient norm through repeated compositions, and error after a chain of 5 to 10 compositions. Success is near-linear error growth with chain length, lower gradient variance, and lower latency than repeatedly solving support-point or polygon-sum optimization.

Verification

Beats tuned baseline

Stage 1 · Toy mechanism gate: Passed ✓

Stage 2 · Mechanism transferred to benchmark: Confirmed ✓

Stage 2 · Practical benchmark result: Significant win ✓

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

Stage 1 — Mechanism check agent confidence 8/10

Built a NumPy MVP for direction-indexed convex latents with componentwise nonnegative Minkowski addition, scaling, convex-hull decoding, and Hausdorff evaluation. Across 300 trials, additive and scaling support identities had zero measured error, while convexification had maximum perturbation ratio 1.0, confirming the claimed nonexpansiveness. In chain tests of length 2–10, structured addition was 7.5–19.5x faster than repeatedly forming pairwise vertex sums and hulls, although finite-direction decoding introduced nonzero approximation error that reached about 0.13 in the longest test.

Agent confidence: 8/10

Baseline: Generic pairwise convex-hull Minkowski composition; chain output size grew from 8 to 51 vertices.
Idea: Tuple composition; median 12.8x runtime speedup. Maximum additive/scaling identity error was 0.0, maximum convexification Lipschitz ratio was 1.0, and longest-chain decoded Hausdorff error was 0.1307.

Limitations: Only small 2D random polygons were tested. No learned predictor, projected-gradient margin enforcement, 3D experiment, GPU benchmark, or MLP baseline was included. The generic baseline computes exact hull-based sums, while the structured method uses a finite direction set and trades exactness for speed.

How to run: python3 minkowski_latents.py

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

Beats the tuned baseline by 95.1% (p=0.0081, wins 8 / 8 paired seeds; metric: lower is better).

Benchmark: Minkowski_composition
Model: mlp_tiny
Paired seeds: 8
Baseline mean: 0.0205
Idea mean: 0.001
Effect (Δ): -0.0195 (−95.1%; negative = idea better)
Wins: 8 / 8 paired seeds
p-value: 0.0081 (permutation test, 20 000 shuffles)
Smallest detectable effect: ±24.8%
Mechanism: Confirmed ✓
Practical effect: Helps
Baseline tuning: swept over 3 configs

Limitations:

Only the custom 2D ellipse-support-tuple regression track was tested; built-in tabular, vision, sequence, and dynamics tracks were not structurally appropriate. The experiment used 8 directions and did not test projected-gradient cone-margin enforcement, 3D objects, longer learned composition chains, or generic polygon-hull latency.

How to run: python3 stage2_bench.py

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

Stage 2 — Benchmark Sep 3, 2026 latest Worked ✓

Agent confidence: 8/10

Implemented an end-to-end Minkowski-additive convex latent network and a deterministic custom regression track matching the idea's structure. Across 8 paired seeds, the idea achieved mean test MSE 0.001009 versus 0.020459 for the baseline, winning all 8 pairs with permutation p=0.0081; therefore the benchmark verdict is idea better (significant).

Baseline: mean test MSE 0.0204591077, std 0.0058978452, best lr=0.01
Idea: mean test MSE 0.0010090163, std 0.0002896170, paired delta=-0.0194500914, 8/8 wins, p=0.0081; mechanism observed mean additivity error=0.1063277, median amplification=1.3048688, p90=1.5228297, confirmed=true

Benchmark result