Tight local approximation results for max-min linear programs

In a bipartite max-min LP, we are given a bipartite graph $\myG = (V \cup I \cup K, E)$, where each agent $v \in V$ is adjacent to exactly one constraint $i \in I$ and exactly one objective $k \in K$. Each agent $v$ controls a variable $x_v$. For each $i \in I$ we have a nonnegative linear constraint on the variables of adjacent agents. For each $k \in K$ we have a nonnegative linear objective function of the variables of adjacent agents. The task is to maximise the minimum of the objective functions. We study local algorithms where each agent $v$ must choose $x_v$ based on input within its constant-radius neighbourhood in $\myG$. We show that for every $\epsilon>0$ there exists a local algorithm achieving the approximation ratio ${\Delta_I (1 - 1/\Delta_K)} + \epsilon$. We also show that this result is the best possible – no local algorithm can achieve the approximation ratio ${\Delta_I (1 - 1/\Delta_K)}$. Here $\Delta_I$ is the maximum degree of a vertex $i \in I$, and $\Delta_K$ is the maximum degree of a vertex $k \in K$. As a methodological contribution, we introduce the technique of graph unfolding for the design of local approximation algorithms.

💡 Research Summary

The paper investigates distributed local algorithms for a class of linear programs called bipartite max‑min LPs. The underlying communication structure is a bipartite graph G = (V ∪ I ∪ K, E) where each variable‑controlling agent v ∈ V is incident to exactly one constraint node i ∈ I and one objective node k ∈ K. For each constraint i the agents in V_i must satisfy a non‑negative linear inequality ∑{v∈V_i} a{iv} x_v ≤ 1, and for each objective k the agents in V_k contribute to a non‑negative linear function ∑{v∈V_k} c{kv} x_v. The goal is to maximize the minimum value of all objective functions, i.e., to maximize ω such that ∑{v∈V_k} c{kv} x_v ≥ ω for every k.

A local algorithm is defined as one where each agent decides its variable x_v based solely on information contained within a constant‑radius neighbourhood in G. The authors assume only port‑numbering (each node can distinguish incident edges by locally assigned numbers) and no unique identifiers.

Positive Result (Theorem 1).
For any integers Δ_I ≥ 2, Δ_K ≥ 2 and any ε > 0, there exists a deterministic local algorithm with approximation ratio
α = Δ_I · (1 − 1/Δ_K) + ε.
The algorithm works as follows. First, the input graph is “unfolded” into its universal covering tree T. Unfolding replaces every cycle by a fresh copy, yielding an (infinite) tree that preserves the local view of each node up to any finite radius. Because the algorithm only needs a constant radius, the agent’s view in G is indistinguishable from its view in T.

The tree is then regularised: each constraint node is given exactly Δ_I incident agents and each objective node exactly Δ_K agents, by adding dummy agents with zero coefficients that do not affect feasibility or objective value. This yields a countably infinite regular tree where every local neighbourhood looks the same.

Each agent u collects all objectives within distance 4L + 1 (for a suitably chosen constant L depending on Δ_I, Δ_K, ε). For each such objective k, the agent extracts the subgraph G(k, L) consisting of the objective, the surrounding constraints up to distance 4L + 2, and all incident agents. This subgraph is a finite tree of bounded size. The agent solves the restricted max‑min LP on G(k, L) optimally (this can be done locally because the subgraph is small) and obtains a local solution x^{(k)}. Finally, the agent averages the values obtained from all objectives in its collection to produce its final decision x_u. This averaging preserves feasibility (each constraint sees at most Δ_I contributions) and guarantees that every objective receives at least a 1/α fraction of the optimal value, yielding the claimed approximation ratio.

Negative Result (Theorem 2).
The same ratio is shown to be optimal: no deterministic local algorithm (even with unique identifiers and 0/1 coefficients) can achieve an approximation better than Δ_I · (1 − 1/Δ_K). The proof constructs families of bounded‑degree bipartite graphs with large girth (no short cycles). Because a local algorithm’s view is limited to a constant radius, it cannot distinguish between a tree and a high‑girth graph that locally looks identical. By carefully setting coefficients, the authors force any algorithm that makes decisions based only on local information to violate the desired bound on at least one objective, establishing the lower bound.

Further Lower Bound (Theorem 3).
For graphs that satisfy a bounded relative growth condition (the number of vertices within radius r + 2 grows by at most a factor 1 + δ relative to radius r beyond some constant radius), the authors prove that any local algorithm must have approximation ratio at least 1 + δ/2. This shows that even under strong structural restrictions, the dependence on the degree parameters cannot be eliminated.

Methodological Contribution.
The central technical tool is the unfolding technique, which translates a finite (or countably infinite) graph into its universal covering tree. While unfolding has traditionally been used to prove impossibility results, the authors repurpose it to design algorithms: by working on the tree, they can exploit its regularity and symmetry, then map the solution back to the original graph using only local information. The averaging of solutions from overlapping local LPs is another key idea, reminiscent of previous work on distributed packing and covering problems but adapted to the max‑min setting.

Implications.
The results give a tight characterization of what can be achieved by constant‑radius distributed algorithms for bipartite max‑min LPs. The approximation factor Δ_I (1 − 1/Δ_K) + ε is generally larger than the factor 1 + ε obtainable for pure packing or covering LPs, reflecting the intrinsic difficulty of simultaneously maximizing a minimum. Nevertheless, the algorithm is simple, requires only port‑numbering, and works on arbitrary bounded‑degree graphs, making it applicable to practical scenarios such as sensor‑network data aggregation, load balancing, and resource allocation where agents have only local knowledge.

In summary, the paper delivers a complete picture: a constructive local algorithm achieving the best possible approximation ratio, a matching impossibility proof, and a novel methodological framework (graph unfolding) that may be useful for other distributed optimization problems.