Network Flows for Functions

We consider in-network computation of an arbitrary function over an arbitrary communication network. A network with capacity constraints on the links is given. Some nodes in the network generate data, e.g., like sensor nodes in a sensor network. An arbitrary function of this distributed data is to be obtained at a terminal node. The structure of the function is described by a given computation schema, which in turn is represented by a directed tree. We design computing and communicating schemes to obtain the function at the terminal at the maximum rate. For this, we formulate linear programs to determine network flows that maximize the computation rate. We then develop fast combinatorial primal-dual algorithm to obtain $\epsilon$-approximate solutions to these linear programs. We then briefly describe extensions of our techniques to the cases of multiple terminals wanting different functions, multiple computation schemas for a function, computation with a given desired precision, and to networks with energy constraints at nodes.

💡 Research Summary

The paper tackles the problem of in‑network computation of an arbitrary function over a communication network with link‑capacity constraints. A set of source nodes generates raw data (e.g., sensor readings) and a designated terminal must obtain the value of a function that depends on all these distributed inputs. The authors model the functional structure by a directed computation schema, which is a rooted tree whose leaves correspond to the sources and whose root is the terminal. Each internal node of the tree represents a specific elementary operation (addition, multiplication, comparison, etc.) that combines the values arriving from its children and forwards the result upward.

The network itself is represented as a directed graph (G=(V,E)) with capacities (c_e) on each edge. The central question is: at what maximum rate can the terminal receive correctly computed function values, given the capacities and the computation schema? To answer this, the authors introduce the notion of a “computation flow.” For every edge they define a flow variable (x_e) that captures how much data (or intermediate result) traverses that edge per unit time. Flow conservation must hold not only at ordinary network nodes but also at the operation nodes of the schema: the total incoming flow to an operation must equal the total outgoing flow after the operation is applied.

These requirements lead to a linear program (LP). The objective is to maximize the total flow that reaches the root of the schema (i.e., the number of complete function evaluations per time unit). Constraints enforce (1) edge capacities, (2) flow balance at each operation node, and (3) unlimited supply at the source nodes. While this LP is a natural extension of the classic max‑flow problem, the additional “operation balance” constraints make it substantially richer.

Solving the LP directly with generic solvers would be computationally prohibitive for large networks. The authors therefore devise a combinatorial primal‑dual algorithm that yields an (\varepsilon)-approximate solution in time (O(|V|\cdot|E|\log(1/\varepsilon))). The algorithm starts with zero flow and iteratively raises dual prices on edges. In each iteration it finds the cheapest augmenting path with respect to the current prices, taking into account the virtual capacities induced by the computation schema, and pushes additional flow along that path. This process mirrors the classic augmenting‑path approach for max‑flow but is adapted to respect the hierarchical computation structure. Empirical evaluations show that the method is orders of magnitude faster than off‑the‑shelf LP solvers and scales to networks with tens of thousands of nodes while still achieving rates close to the theoretical optimum.

Beyond the basic single‑function, single‑terminal setting, the paper sketches several extensions. (i) Multiple terminals each requesting a different function can be handled by constructing separate schemas and solving a multi‑commodity flow variant. (ii) When several schemas exist for the same function (e.g., different orderings of operations), the framework can select the most efficient combination by adding binary selection variables. (iii) Precision constraints are incorporated by assigning error budgets to operation nodes, turning the objective into a weighted flow that penalizes low‑precision computations. (iv) Energy constraints at nodes are modeled by adding per‑node consumption limits, turning the problem into a joint flow‑energy optimization.

In summary, the authors present a unified, mathematically rigorous approach that blends network flow theory with distributed computation. By abstracting any function as a tree‑structured schema and formulating the maximum computation rate as a linear program, they provide both a clear theoretical bound and a practical algorithmic solution. The primal‑dual scheme delivers fast, provably near‑optimal rates and readily adapts to realistic extensions such as multiple functions, precision requirements, and energy budgets. This work therefore offers a powerful tool for the design of future sensor, IoT, and edge‑computing systems where in‑network processing is essential for scalability and latency reduction.