Intractability of approximate multi-dimensional nonlinear optimization on independence systems
We consider optimization of nonlinear objective functions that balance $d$ linear criteria over $n$-element independence systems presented by linear-optimization oracles. For $d=1$, we have previously
We consider optimization of nonlinear objective functions that balance $d$ linear criteria over $n$-element independence systems presented by linear-optimization oracles. For $d=1$, we have previously shown that an $r$-best approximate solution can be found in polynomial time. Here, using an extended Erd\H{o}s-Ko-Rado theorem of Frankl, we show that for $d=2$, finding a $\rho n$-best solution requires exponential time.
💡 Research Summary
The paper investigates the computational difficulty of optimizing nonlinear objective functions that balance multiple linear criteria over independence systems when the systems are accessed only through linear‑optimization oracles. An independence system is a pair ((E,\mathcal I)) where (E) is a ground set of size (n) and (\mathcal I\subseteq2^{E}) is a family closed under taking subsets. For each element (e\in E) we are given (d) linear weight vectors, inducing linear functions (c^{1},\dots ,c^{d}:\mathcal I\to\mathbb R). The goal is to maximize a nonlinear aggregation (f(c^{1}(S),\dots ,c^{d}(S))) over all feasible sets (S\in\mathcal I). The only access to (\mathcal I) is via an oracle that, given a linear objective (\lambda\in\mathbb R^{E}), returns a set (S\in\mathcal I) maximizing (\sum_{e\in S}\lambda_e).
The authors first recall their earlier result for the single‑criterion case ((d=1)). There they proved that for any fixed integer (r) an (r)-best solution—i.e., a feasible set whose objective value is at least as large as the (r)-th best value—can be found in time polynomial in (n) using only the linear‑optimization oracle. The algorithm proceeds by repeatedly querying the oracle with carefully chosen linear combinations of the original weight vector, thereby constructing a short list of candidate solutions that is guaranteed to contain an (r)-best set.
The central contribution of the present work is a stark contrast for the two‑criterion case ((d=2)). The authors consider the problem of finding a (\rho n)-best solution, where (\rho\in(0,1)) is a fixed constant and (\rho n) denotes a rank that grows linearly with the input size. They prove that any algorithm that guarantees such a solution must, in the worst case, run in exponential time (2^{\Omega(n)}). The proof hinges on an extended Erdős–Ko–Rado theorem due to Frankl, which characterizes the maximum size of a family of (k)-subsets with prescribed intersection properties.
The construction proceeds as follows. Each ground element (e_i) is assigned a pair of weights ((a_i,b_i)) corresponding to the two linear criteria. The nonlinear objective (f) is taken to be a simple but non‑linear function such as (f(x,y)=\min{x,y}) or (f(x,y)=x\cdot y). Using Frankl’s theorem, the authors build a large family (\mathcal F\subseteq\mathcal I) of feasible sets that are almost pairwise disjoint (or have bounded intersections). Within this family the linear criterion values ((c^{1}(S),c^{2}(S))) are tightly clustered, yet the nonlinear aggregation (f) creates a spread of values that is linear in (n). Consequently, the optimal solution and the (\rho n)-th best solution differ by (\Theta(n)) in objective value, and distinguishing them requires examining essentially all subsets in (\mathcal F). Since (|\mathcal F|=2^{\Omega(n)}), any algorithm that guarantees a (\rho n)-best solution must perform an exponential number of oracle calls or equivalent work.
This result demonstrates a phase transition: while a single linear criterion admits efficient approximation (any fixed‑rank approximation is polynomial), the addition of just one more criterion destroys this tractability. The hardness is not an artifact of a pathological objective; it holds for natural nonlinear aggregations and for independence systems that are extremely general (the only assumption is oracle access). Thus, the paper establishes that the “balance of two linear goals” problem is fundamentally intractable under the standard oracle model.
Beyond the theoretical lower bound, the authors discuss implications for practical domains such as network design, resource allocation, and multi‑objective scheduling, where decision makers often need to balance several performance metrics. The exponential lower bound suggests that, unless additional structure is present (e.g., matroid constraints, submodular objectives, or special geometry of the weight vectors), one cannot hope for polynomial‑time algorithms that guarantee a solution within a linearly‑scaled rank of optimality.
The paper concludes with several avenues for future research. First, it suggests investigating restricted families of independence systems (e.g., matroids, matchings, or graphic matroids) where the hardness might be mitigated. Second, it proposes studying subclasses of nonlinear objectives—such as submodular, concave, or convex aggregations—to see whether they admit better approximation guarantees. Third, the authors encourage the development of heuristic or randomized algorithms that, while lacking worst‑case guarantees, perform well empirically on realistic instances. Finally, they note that extending the lower bound to higher dimensions ((d\ge3)) appears straightforward using similar combinatorial constructions, reinforcing the view that multi‑criterion nonlinear optimization over independence systems is intrinsically hard.
In summary, the paper delivers a clean dichotomy: for one linear criterion, any fixed‑rank approximation is efficiently attainable; for two or more criteria, even a modest approximation measured by a linear fraction of the rank becomes exponentially hard. This contributes a fundamental insight to the theory of combinatorial optimization, highlighting the delicate interplay between problem dimensionality, objective nonlinearity, and the power of oracle‑based algorithms.
📜 Original Paper Content
🚀 Synchronizing high-quality layout from 1TB storage...