Curvature-Conditioned Allocation

• Curvature-conditioned allocation is an approach that uses curvature metrics to modulate resource distribution instead of relying solely on raw scores.
• It spans domains such as linear attention, greedy and projection-free optimization, and hypergraph analysis, enhancing performance and theoretical guarantees.
• The strategy refines decision-making by incorporating measures like total, partial, local, and Forman curvature to capture nonlinearity in complex systems.

Searching arXiv for the cited papers and related terminology. Search query: "Curvature-Conditioned Query linear attention (Le et al., 31 May 2026)" Taken together, the literature suggests an umbrella notion of curvature-conditioned allocation: an allocation rule in which a resource, contribution, update, or readout is modulated by a curvature quantity rather than by raw scores alone. In the works considered here, the allocated object ranges from greedy selections under matroid or knapsack constraints, to projection-free step sizes, to layer capacity in LLMs, to Shapley-value distributions on hypergraphs, and to read-time query transformations in linear attention. The curvature object likewise varies—total curvature, partial curvature, batch curvature, Forman curvature, local Lipschitz estimators, running key covariance, or block-Hessian-adjusted gains—but in each case curvature is used to refine decisions that would otherwise be curvature-blind (Liu et al., 2017, Liu et al., 2015, Yamada, 2021, Giang-Tran et al., 15 May 2026, Amaefuna et al., 1 Mar 2026, Le et al., 31 May 2026).

1. Scope across research areas

The literature represented here spans several distinct technical settings in which curvature enters an allocation rule.

Setting	Curvature quantity	Allocation target
Linear attention	running key covariance $\Sigma_t$	clean query $q_t^{\rm clean}$ before read
Matroid and greedy optimization	total curvature $c(f)$, partial curvature $b(f)$, total curvature $\alpha_k$	greedy or $k$-batch greedy selection
Projection-free optimization	local Lipschitz estimator $L_t$	closed-loop step size $\gamma_t$
Layer-adaptive LLM optimization	curvature-adjusted layer gain $\zeta_k^2$, quality scores $q_k$	expert slots, LoRA rank, sparsity
Hypergraph cooperative games	Forman curvature of the hyperedge	individual Shapley allocation $q_t^{\rm clean}$0
Knapsack and matroid approximation	bounded total curvature $q_t^{\rm clean}$1	continuous-greedy and local-search decisions

In discrete optimization, curvature measures how far a monotone set function is from additivity or linearity, and the resulting bounds sharpen greedy guarantees when curvature is small (Liu et al., 2017, Liu et al., 2015, Yoshida, 2016, Sviridenko et al., 2013). In learning systems, curvature is used more operationally: the query is contracted along high-density memory directions in linear attention, the step size is computed from a local curvature proxy in Frank–Wolfe methods, and layer resources are allocated according to second-order gains under an MDL objective (Le et al., 31 May 2026, Giang-Tran et al., 15 May 2026, Amaefuna et al., 1 Mar 2026). In hypergraph analysis, Forman curvature enters the construction of edge-worth functions whose Shapley decomposition yields a closed-form allocation over vertices (Yamada, 2021).

A plausible implication is that curvature-conditioned allocation is not a single theorem or framework, but a recurring design principle in which curvature acts as a control variable for distributing scarce computational, combinatorial, or cooperative resources.

2. Mathematical role of curvature

In the submodular and polymatroid setting, the classical total curvature is

$q_t^{\rm clean}$2

with $q_t^{\rm clean}$3 and $q_t^{\rm clean}$4 iff $q_t^{\rm clean}$5 is additive (Liu et al., 2017). When the function is defined only on the feasible family $q_t^{\rm clean}$6, partial curvature replaces total curvature:

$q_t^{\rm clean}$7

so that $q_t^{\rm clean}$8 depends only on marginals over feasible sets and satisfies $q_t^{\rm clean}$9 (Liu et al., 2017). For $c(f)$0-batch greedy, the relevant notion is

$c(f)$1

with $c(f)$2 for nondecreasing submodular objectives (Liu et al., 2015).

A different curvature notion appears for general monotone set functions under a matroid:

$c(f)$3

This generalized curvature yields a $c(f)$4 approximation for maximization and a $c(f)$5 approximation for minimization by greedy algorithms (Sviridenko et al., 2013). Under knapsack constraints, bounded total curvature $c(f)$6 similarly interpolates between the linear and fully submodular regimes (Yoshida, 2016).

In linear attention, curvature is derived from the softmax log-partition

$c(f)$7

A second-order Taylor expansion at $c(f)$8 gives

$c(f)$9

where

$b(f)$0

Here the Hessian coincides with the running key covariance, which identifies the high-density directions of memory (Le et al., 31 May 2026).

In auto-conditioned Frank–Wolfe, curvature is estimated locally by

$b(f)$1

and this feeds directly into the closed-loop step-size rule

$b(f)$2

where $b(f)$3 is updated recursively from $b(f)$4 and a damping schedule (Giang-Tran et al., 15 May 2026).

In layer-adaptive LLM optimization, the central quantity is the curvature-adjusted layer gain

$b(f)$5

which equals twice the maximal second-order reduction in empirical risk achievable by updating layer $b(f)$6 alone. Normalization gives the quality score

$b(f)$7

which then drives both capacity allocation and pruning programs (Amaefuna et al., 1 Mar 2026).

3. Greedy, batch, and constrained allocation under curvature

For polymatroid maximization under a matroid of rank $b(f)$8, Conforti–Cornuéjols-type bounds depend explicitly on total curvature. If $b(f)$9 is greedy and $\alpha_k$0 is optimal, then

$\alpha_k$1

and for a uniform matroid,

$\alpha_k$2

When only feasible-set information is available, partial curvature improves these guarantees. For any extension $\alpha_k$3 of $\alpha_k$4 to $\alpha_k$5, one has $\alpha_k$6, and if there exists an extension with $\alpha_k$7, then the guarantees become

$\alpha_k$8

The same paper gives necessary and sufficient conditions for extending a polymatroid function from the uniform matroid of rank $\alpha_k$9 to rank $k$0, together with an incremental-extension algorithm (Liu et al., 2017).

The $k$1-batch greedy strategy generalizes one-element-at-a-time greedy by selecting a $k$2-element block at each step. Its performance is controlled by $k$3, with

$k$4

for a general matroid and

$k$5

for a uniform matroid with $k$6 (Liu et al., 2015). Because $k$7 when $k$8, larger batches have better harmonic and exponential bounds. In the task-assignment example with $k$9 and $L_t$0, the paper computes $L_t$1 and $L_t$2, with harmonic bounds $L_t$3 and $L_t$4 (Liu et al., 2015).

Under a knapsack constraint, bounded curvature yields approximation factors beyond the classical $L_t$5 barrier. For monotone submodular maximization with total curvature $L_t$6, a polynomial-time algorithm achieves approximation ratio $L_t$7, and the ratio is tight up to $L_t$8 for any $L_t$9 (Yoshida, 2016). Under a single matroid constraint, a polynomial-time algorithm achieves $\gamma_t$0 approximation for nondecreasing submodular maximization with curvature $\gamma_t$1, and this is best possible in the value oracle model (Sviridenko et al., 2013). Both works rely on decompositions into a submodular part plus a linear part and then apply curvature-aware continuous-greedy or local-search machinery.

4. Curvature-conditioned mechanisms in modern learning systems

In linear attention, the central problem is that the read step remains unchanged even when write-side remedies are added: every past key contributes additively to the output, so useful targets are diluted by the bulk of stored vectors. "Curvature-Conditioned Query" (CCQ) addresses this by contracting the query along the high-density directions of the running key covariance before the read:

$\gamma_t$2

CCQ modifies only the read step and is composable with any linear-attention backbone. The covariance can be maintained recurrently or chunkwise, with extra per-head cost $\gamma_t$3 for $\gamma_t$4 and an additional $\gamma_t$5 matvec for $\gamma_t$6 (Le et al., 31 May 2026). Empirically, on 500M models, CCQ-Gated DeltaNet reduces WikiText PPL from $\gamma_t$7 and raises 7-task Avg $\gamma_t$8; on 1.3B, CCQ-GLA cuts WikiText PPL from $\gamma_t$9; on 14-task English LongBench at 1.3B, CCQ-GLA reaches recurrent Avg $\zeta_k^2$0 versus $\zeta_k^2$1 for GLA; and on pass-key retrieval it recovers to $\zeta_k^2$2, $\zeta_k^2$3, and $\zeta_k^2$4 where GLA collapses past $\zeta_k^2$5 (Le et al., 31 May 2026).

Auto-conditioned Frank–Wolfe algorithms use curvature in a different sense. They replace a global Lipschitz constant in closed-loop step sizes with a local Lipschitz estimator computed from first-order information along the iterates. The resulting abstraction covers standard Frank–Wolfe, Matching Pursuit, pairwise Frank–Wolfe, and away-step Frank–Wolfe, while remaining line-search-free (Giang-Tran et al., 15 May 2026). The framework proves convergence to stationary points in the nonconvex setting with an $\zeta_k^2$6 first-order-stationarity rate, recovers the standard $\zeta_k^2$7 sublinear convergence guarantee in the convex setting, and under stronger geometry yields $\zeta_k^2$8 or global linear rates for particular variants (Giang-Tran et al., 15 May 2026).

In layer-adaptive LLM optimization, curvature governs explicit resource allocation. The MDL framework defines layer quality scores from $\zeta_k^2$9 and then solves two convex programs: a capacity allocation program that distributes expert slots or LoRA rank under a hardware budget, and a pruning program that concentrates sparsity on low-gain layers while protecting high-gain layers (Amaefuna et al., 1 Mar 2026). Both programs admit unique closed-form solutions parameterized by a single dual variable and are computable in $q_k$0 via bisection. The paper further proves an $q_k$1 transfer regret bound showing that source-domain allocations remain near-optimal on target tasks when curvature scores drift by $q_k$2 (Amaefuna et al., 1 Mar 2026).

5. Hypergraph allocation via Forman curvature and Shapley values

In hypergraph analysis, Yamada combines the discrete geometry concept of Forman Ricci curvature with the game-theoretic Shapley value in a framework called combinatorial evaluation (Yamada, 2021). The players are the vertices of a directed hypergraph, and each hyperedge contributes an edge-characteristic function $q_k$3 or $q_k$4 chosen so that

$q_k$5

As a result, the total worth $q_k$6 is minus the sum of all edge curvatures (Yamada, 2021).

The resulting “individual Shapley” allocation has a closed form. If $q_k$7 and $q_k$8 are the in-degree and out-degree of vertex $q_k$9, then

$q_t^{\rm clean}$00

This yields a linear-time algorithm: computing all degrees takes $q_t^{\rm clean}$01 and the final allocation is $q_t^{\rm clean}$02 (Yamada, 2021). The allocation satisfies efficiency, additivity, component-efficiency, weak symmetry, and fairness-on-edge, but full Shapley symmetry and the null-player axiom fail in general (Yamada, 2021).

The toy example in the paper gives edge curvatures

$q_t^{\rm clean}$03

with resulting allocation

$q_t^{\rm clean}$04

The paper notes that vertex $q_t^{\rm clean}$05, with $q_t^{\rm clean}$06, emerges far more central than any other by this curvature-conditioned rule (Yamada, 2021).

6. Comparative interpretation, limitations, and recurring misconceptions

A common misconception is that “curvature” denotes a single invariant across these methods. The papers show otherwise. In submodular optimization, curvature measures departure from additivity or modularity; in linear attention, the relevant curvature is the Hessian of the softmax log-partition at the isotropic point and equals the running key covariance; in auto-conditioned Frank–Wolfe, it is a local Lipschitz estimate along a trial step; in layer-adaptive optimization, it is a block-Hessian-adjusted gain; and in hypergraphs it is Forman curvature on directed hyperedges (Liu et al., 2017, Le et al., 31 May 2026, Giang-Tran et al., 15 May 2026, Amaefuna et al., 1 Mar 2026, Yamada, 2021).

Another misconception is that curvature conditioning must modify an entire algorithm. Several of the methods are intentionally minimal. CCQ leaves the write rule untouched and changes only the read step by overwriting $q_t^{\rm clean}$07 before the state read (Le et al., 31 May 2026). Partial curvature can certify greedy performance without explicitly constructing an extension to the full power set (Liu et al., 2017). Auto-conditioned Frank–Wolfe keeps the closed-loop form of the step-size rule and only substitutes a local estimator for the global smoothness constant (Giang-Tran et al., 15 May 2026). In the MDL framework, both allocation and pruning reduce to solving for a single dual variable by bisection (Amaefuna et al., 1 Mar 2026).

The limitations are equally specific. CCQ uses an unweighted, $q_t^{\rm clean}$08-independent $q_t^{\rm clean}$09 instead of the true $q_t^{\rm clean}$10-weighted covariance, and its Taylor expansion is centered at $q_t^{\rm clean}$11; the paper also reports that replacing $q_t^{\rm clean}$12 by a constant or using raw $q_t^{\rm clean}$13 instead of $q_t^{\rm clean}$14 leads to instabilities, while the GLA-Hedgehog feature-map ablation often hurts retrieval (Le et al., 31 May 2026). For partial curvature, extension to the full power set is not guaranteed in general, and computing $q_t^{\rm clean}$15 is $q_t^{\rm clean}$16 for rank-$q_t^{\rm clean}$17 matroids and can be $q_t^{\rm clean}$18 in the worst case for uniform matroids (Liu et al., 2017). In hypergraph allocation, the failure of full Shapley symmetry and null-player axioms marks a deliberate departure from standard cooperative-game desiderata (Yamada, 2021). In bounded-curvature approximation, the strongest factors are accompanied by matching impossibility statements: $q_t^{\rm clean}$19 is tight up to $q_t^{\rm clean}$20 under knapsack constraints, and $q_t^{\rm clean}$21 is best possible in the value oracle model for a single matroid (Yoshida, 2016, Sviridenko et al., 2013).

These works therefore present curvature-conditioned allocation not as a single mature doctrine, but as a recurring technical strategy: define a curvature object that captures nonlinearity or local geometry, and then use it to allocate decisions more selectively than a curvature-blind baseline would permit.