Unverified 2026

Submodular Budget Router

Implementation & benchmark of arXiv:2607.10683 — Extended generalized permutahedra, and cointeracting bialgebras

Usefulness6/10
Difficulty5/10
Novelty6/10

Source paper: Extended generalized permutahedra, and cointeracting bialgebras arXiv:2607.10683 ⓘ · analyzed Aug 30, 2026

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

Idea description

Replace independent top-k MoE routing with a submodular polyhedral allocation over experts. A learned set function assigns a marginal gain to each additional expert allocation, so the router exhibits diminishing returns and can enforce global capacity constraints rather than making unrelated per-token choices. The allocation is obtained by sorting marginal gains, giving a fast greedy router with piecewise-linear routing regions.

Formulas

$$z(A)+z(B)\ge z(A\cup B)+z(A\cap B),\qquad z(\varnothing)=0$$
$$P(z)=\left\{x\in\mathbb{R}^{I}:x(S)=\sum_{i\in S}x_i\le z(S)\ \forall S\subseteq I,\quad x(I)=z(I)\right\}$$
$$w_{i_1}\ge\cdots\ge w_{i_m},\quad S_j=\{i_1,\ldots,i_j\},\quad x_{i_j}=z(S_j)-z(S_{j-1})$$
$$\Delta(\Pi)=\sum_{I=S\sqcup T,\;1_S\text{ bounded on }\Pi}(\Pi_{|S},\Pi_{/S})$$

Mathematical statement

The paper uses the bijection between extended generalized permutahedra and submodular functions. For a ground set I of experts, a normalized submodular function is a map z:2^I -> R satisfying z(emptyset)=0 and z(A)+z(B) >= z(A union B)+z(A intersection B). Its associated generalized permutahedron is P(z)={x in R^I: x(S)=sum_{i in S}x_i <= z(S) for every S subseteq I, and x(I)=z(I)}. For a score vector w, sort experts as i_1,...,i_m so that w_{i_1} >= ... >= w_{i_m}; the maximizing vertex of P(z) is x_{i_j}=z(S_j)-z(S_{j-1}), where S_j={i_1,...,i_j} and S_0=emptyset. Thus each ordered region, or normal cone, is indexed by a preorder of experts, and the allocation is affine within that region. The paper also gives the decomposition Delta(Pi)=sum_{I=S disjoint union T, 1_S bounded on Pi}(Pi_|S,Pi_/S), motivating separate capacity accounting for expert subsets. The useful computational property is diminishing marginal allocation: later increments z(S_j)-z(S_{j-1}) cannot increase as S_j grows.

Implementation notes

Integrate this at the MoE router immediately after the router network produces token-expert logits W in R^{B x E}, where B is the token count and E is the number of experts. For an MVP, use a monotone submodular function z(S)=c(|S|), with c(0)=0 and c(r)=C(1-exp(-r/tau)); tau controls diminishing returns and C sets total routing mass. For a richer version, use z(S)=sum_h a_h min(r_h, |S intersect G_h|), where a_h>=0, r_h>=0, and G_h are expert groups. For each token, sort logits w_e in descending order, compute delta_j=z(S_j)-z(S_{j-1}), set x[i_j]=relu(delta_j), retain the first k positive assignments, and normalize x to sum to one. Dispatch token features using x. To enforce hardware capacity, rank candidate assignments by w_be*x_be, retain the highest-priority assignments for each expert up to capacity, then renormalize surviving weights; optionally add an auxiliary loss on expert loads. Pseudocode: logits=W[b]; order=argsort_desc(logits); S=empty; for e in order: delta=z(S union {e})-z(S); x[e]=relu(delta); S.add(e); x=normalize(top_k(x,k)); dispatch(x). The mathematical quantities are the submodular increments and greedy vertex; learnable quantities are logits, tau, group weights, and optionally z. Begin with an 8-expert Switch-Transformer-style model on Wikitext-103 or CIFAR-100, comparing against top-1 and top-2 routing at equal expert FLOPs and capacity factor. Measure validation loss or accuracy, dropped-token rate, expert-load coefficient of variation, routing entropy, and throughput. Success means fewer dropped tokens and better load balance at equal compute, or faster loss descent and lower perplexity than top-k routing.

Verification

This idea has not been verified yet.

Verification happens in two stages: Stage 1 — a mechanism check on a toy system confirms the claimed mathematical phenomenon reproduces; Stage 2 — a benchmark implements the idea on a real (small) neural network task and compares it against a tuned baseline over 8 paired seeds with a permutation test.

Artifacts

Artifacts unavailable.