On the Solvability of Byzantine-tolerant Reliable Communication in Dynamic Networks

A reliable communication primitive guarantees the delivery, integrity, and authorship of messages exchanged between correct processes of a distributed system. We investigate the necessary and sufficient conditions for reliable communication in dynamic networks, where the network topology evolves over time despite the presence of a limited number of Byzantine faulty processes that may behave arbitrarily (i.e., in the globally bounded Byzantine failure model). We identify classes of dynamic networks where such conditions are satisfied, and extend our analysis to message losses, local computation with unbounded finite delay, and authenticated messages.

💡 Research Summary

The paper investigates the fundamental requirements for implementing a reliable communication primitive in dynamic networks that may contain a bounded number of Byzantine faulty processes. A reliable communication primitive guarantees three properties: (i) integrity (messages are not altered in transit), (ii) delivery (messages eventually reach the intended correct recipient), and (iii) authorship (the sender cannot be forged). The authors extend the earlier work of Maurer et al. (which addressed a single source‑target pair) to the general case where all pairs of correct processes must be able to communicate reliably, regardless of the time at which communication occurs.

The central technical contribution is the definition of Dynamic Minimum Cut (DynMinCut) between two processes p_s and p_t in an evolving graph G. A journey is a time‑ordered sequence of edges that respects the presence of links at each time step. For a given pair (p_s, p_t), the set Σ(p_s, p_t) contains all intermediate node sets of possible journeys. DynMinCut(p_s, p_t) is the size of a minimum hitting set for Σ(p_s, p_t); equivalently, it is the smallest number of correct nodes whose removal destroys every journey from p_s to p_t. The authors prove that DynMinCut(p_s, p_t) > f (where f is the globally known upper bound on Byzantine processes) is both necessary and sufficient for reliable communication between p_s and p_t. This condition generalizes the classic static result that a (2f + 1)-connected graph tolerates f Byzantine faults, now expressed in a time‑varying context.

Because computing DynMinCut in an arbitrary evolving graph is NP‑complete, the paper identifies several polynomial‑time‑checkable classes of dynamic networks that satisfy the condition. These include:

1. Δ‑continuous connectivity – every sliding window of Δ time steps induces a static graph that is (2f + 1)-connected.
2. Structural repetition – networks whose underlying topology belongs to a family (trees, planar graphs, grids) that repeats periodically, guaranteeing at least (2f + 1) node‑disjoint journeys in each period.
3. Periodic high‑degree connectivity – each node maintains a degree above a threshold in each period, ensuring sufficient redundancy.

For each class, verification can be performed in O(n·T) time (n = number of processes, T = number of snapshots), making the approach practical for real‑world dynamic systems such as IoT or mobile ad‑hoc networks.

The authors then broaden the system model. The original synchronous model assumes Perfect Links (PL) and Synchronous Computation (SC), where a message sent over a present link is received instantly and local computation takes zero time. They show that the same DynMinCut condition holds under two more realistic settings:

• Fair‑Loss Links (FLL) + Asynchronous Computation (AC) – links may drop messages, but if a correct process repeatedly sends a message infinitely often, a correct neighbor receives it infinitely often. Local computation may take an unknown finite amount of time. The condition remains unchanged because the existence of infinitely many attempts guarantees the same journey structure.

• Authenticated messages – when processes can attach cryptographic signatures (or any unforgeable authentication), Byzantine nodes cannot masquerade as others. In this setting the required connectivity drops from (2f + 1) to (f + 1), i.e., DynMinCut(p_s, p_t) > f is sufficient even if only (f + 1) node‑disjoint journeys exist, because a single correct node can validate the origin of a message.

The paper also establishes a dynamic version of Menger’s theorem, linking the number of node‑disjoint journeys to DynMinCut, and shows that the hitting‑set formulation is mathematically equivalent to the cut formulation in the temporal domain.

Experimental validation is performed via simulations on three families of networks: (i) static (2f + 1)-connected graphs, (ii) dynamic trees, grids, and planar graphs that satisfy the periodic repetition property, and (iii) random churn models where nodes join and leave. The simulations confirm that when the identified classes are satisfied, all correct processes achieve reliable communication despite Byzantine behavior, message losses, and asynchronous computation.

In summary, the paper delivers a comprehensive theoretical framework for Byzantine‑tolerant reliable communication in evolving networks. It provides a clear, necessary and sufficient structural condition (DynMinCut > f), identifies practically verifiable network classes, extends the result to asynchronous and lossy environments, and shows how authentication can relax connectivity requirements. This work bridges a gap between static fault‑tolerant communication theory and the realities of modern dynamic distributed systems, offering both rigorous proofs and actionable guidelines for system designers.