Perfect Multi-User Distributed Computing

TL;DR

The paper studies a multi-user distributed computing setting where each user’s function is a linear combination of subfunctions, reformulated as a matrix factorization $F = D E$. It derives bounds on two key costs, the cumulative computation cost $Gamma$ and the worst-case delay $Lambda$, by connecting them to the packing radius and packing density of a code whose parity-check matrix is $D$. Central to the results is the use of perfect and quasi-perfect codes to achieve near-optimal or optimal finite-dimensional performance, with a concrete one-shot example illustrating the framework. The work creates a novel bridge between coded distributed computing and classical coding theory, suggesting new design principles for efficient, delay-aware distributed computation and data delivery.

Abstract

In this paper, we investigate the problem of multi-user linearly decomposable function computation, where $N$ servers help compute functions for $K$ users, and where each such function can be expressed as a linear combination of $L$ basis subfunctions. The process begins with each server computing some of the subfunctions, then broadcasting a linear combination of its computed outputs to a selected group of users, and finally having each user linearly combine its received data to recover its function. As it has become recently known, this problem can be translated into a matrix decomposition problem $\mathbf{F}=\mathbf{D}\mathbf{E}$, where $\mathbf{F} \in \mathbf{GF}(q)^{K \times L}$ describes the coefficients that define the users' demands, where $\mathbf{E} \in \mathbf{GF}(q)^{N \times L}$ describes which subfunction each server computes and how it combines the computed outputs, and where $\mathbf{D} \in \mathbf{GF}(q)^{K \times N}$ describes which servers each user receives data from and how it combines this data. Our interest here is in reducing the total number of subfunction computations across the servers (cumulative computational cost), as well as the worst-case load which can be a measure of computational delay. Our contribution consists of novel bounds on the two computing costs, where these bounds are linked here to the covering and packing radius of classical codes. One of our findings is that in certain cases, our distributed computing problem -- and by extension our matrix decomposition problem -- is treated optimally when $\mathbf{F}$ is decomposed into a parity check matrix $\mathbf{D}$ of a perfect code, and a matrix $\mathbf{E}$ which has as columns the coset leaders of this same code.

Figures (1)

• Figure 1: The $K$-user, $N$-server, linearly-decomposable computation setting. After each user informs the master of its desired function $F_k(.)$, each server $n \in [N]$ computes a subfunction $W_l = f_{l}(.)$ in $\mathcal{S}_n \subset [L]$. Afterwards, server $n$ broadcasts a linear combination ${z}_{n}$ (of the locally available computed files) to all users in $\mathcal{T}_{n} \subseteq [K]$. This combination is defined by the coefficients $e_{n,l}$. Finally, based on some decoding-coefficient vectors (based on some decoding-coefficient vectors, to be described later on), each user $k \in [K]$ linearly combines (based on decoding vectors $\mathbf{d}_k$) all the received signals. Decoding must produce for each user its desired function $F_k(.)$.

Theorems & Definitions (12)

• Theorem 1
• proof
• Theorem 2
• proof
• Remark 1
• Proposition 1
• proof
• Proposition 2
• proof
• Proposition 3