All-to-All Communication with Mobile Edge Adversary: Almost Linearly More Faults, For Free

TL;DR

This work studies the communication aspects of this faulty model which allows for almost linearly more edge faults (possibly quadratic), with no extra cost, and develops a new resilient routing scheme which may be of independent interest.

Abstract

Resilient computation in all-to-all-communication models has attracted tremendous attention over the years. Most of these works assume the classical faulty model which restricts the total number of corrupted edges (or vertices) by some integer fault parameter $f$. A recent work by [Bodwin, Haeupler and Parter, SODA 2024] introduced a stronger notion of fault-tolerance, in the context of graph sparsification, which restricts the degree of the failing edge set $F$, rather than its cardinality. For a subset of faulty edges $F$, the faulty-degree $\mathrm{deg}(F)$ is the largest number of faults in $F$ incident to any given node. In this work, we study the communication aspects of this faulty model which allows us to handle almost linearly more edge faults (possibly quadratic), with no extra cost. Our end results are general compilers that take any Congested Clique algorithm and simulate it, in a round by round manner, in the presence of a $α$-Byzantine mobile adversary that controls a $α$-fraction of the edges incident to each node in the fully connected network. For every round $i$, the mobile adversary is allowed to select a distinct set of corrupted edges $F_i$ under the restriction that $\mathrm{deg}(F_i)\leq αn$. In the non-adaptive setting, the $F_i$ sets are selected at the beginning of the simulation, while in the adaptive setting, these edges can be chosen based on the entire history of the protocol up to round $i$. We show general compilers for the non-adaptive, adaptive, and deterministic settings. A key component of our algorithms is a new resilient routing scheme which may be of independent interest. Our approach is based on a combination of techniques, including error-correcting-code, locally decodable codes, cover-free families, and sparse recovery sketches.

Figures (3)

• Figure 1: Node $v_i$ wishes to decode all bits of $\mathrm{Sk}(P_j,\{v_i\})$ from $\mathrm{Sk}_{\ell_i}(P_j)$ (marked as the blue cells). Crucially, these indices are in the same positions $P_j$. Since the LDC is non-adaptive, for a node $v_i$ to be able to decode all blue positions simultaneously, its sufficient to learn the codeword bits given to nodes $\{v_r\}_{r \in N(v_i)}$ (marked as the green cells - due to non-adaptivity of $\mathrm{LDCDecode}$, they are the same positions for all $P_j$ if we use the same randomness to decode them all).
• Figure 2: An illustration of the algorithm of \ref{['lem:det_mobile_high_noise_main']} for $n=4$. Each matrix corresponds to the set of messages a node holds in a given step, where each column $i$ corresponds to the set of messages node $v_i$ holds. Blue arrows correspond to the message exchanges which occur in this step. Different colors of rectangles correspond to different targets, as written in the legend above. Initially each node has a message for each node. In the start of the second step, the first two nodes collectively hold the messages addressed to the first two nodes, and the last two nodes have the symmetric property. Finally, after two steps, all nodes hold their target messages.
• Figure 3: An illustration of the algorithm of \ref{['thm:det_mobile_low_noise_main']} for $n=9$. Each matrix corresponds to the set of messages the nodes hold each of the three steps, where each column $i$ corresponds to the set of messages node $v_i$ holds at that step. Different colors of rectangles correspond to different targets. Initially each node has a message for each node. After Step 1, each of the three segments $S_i \in S_1,S_2,S_3$ collectively hold the set of messages $M(V,S_i)$. Finally, after Step 2, all nodes hold their target messages.

Theorems & Definitions (84)

• Theorem 1.1: Informal
• Definition 1
• Theorem 1.2
• Theorem 1.3
• Theorem 1.4
• Theorem 1.5
• Definition 2: Hamming Distance
• Definition 3: Error Correcting Code
• Lemma 2.1: Justesen Code J72, Theorem 1
• Definition 4: Locally Decodable Codes (LDC)