DEX: Self-Healing Expanders

We present a fully-distributed self-healing algorithm DEX, that maintains a constant degree expander network in a dynamic setting. To the best of our knowledge, our algorithm provides the first efficient distributed construction of expanders - whose expansion properties hold deterministically - that works even under an all-powerful adaptive adversary that controls the dynamic changes to the network (the adversary has unlimited computational power and knowledge of the entire network state, can decide which nodes join and leave and at what time, and knows the past random choices made by the algorithm). Previous distributed expander constructions typically provide only probabilistic guarantees on the network expansion which rapidly degrade in a dynamic setting, in particular, the expansion properties can degrade even more rapidly under adversarial insertions and deletions. Our algorithm provides efficient maintenance and incurs a low overhead per insertion/deletion by an adaptive adversary: only O(log n) rounds and O(log n) messages are needed with high probability (n is the number of nodes currently in the network). The algorithm requires only a constant number of topology changes. Moreover, our algorithm allows for an efficient implementation and maintenance of a distributed hash table (DHT) on top of DEX, with only a constant additional overhead. Our results are a step towards implementing efficient self-healing networks that have guaranteed properties (constant bounded degree and expansion) despite dynamic changes.


Introduction
Modern networks (peer-to-peer, mobile, ad-hoc, Internet, social, etc.) are dynamic and increasingly resemble self-governed living entities with largely distributed control and coordination.In such a scenario, the network topology governs much of the functionality of the network.In what topology should such nodes (having limited resources and bandwidth) connect so that the network has effective communication channels with low latency for all messages, has constant degree, is robust to a limited number of failures, and nodes can quickly sample a random node in the network (enabling many randomized protocols)?The well known answer is that they should connect as a (constant degree) expander (see e.g., [1]).How should such a topology be constructed in a distributed fashion?The problem is especially challenging in a dynamic network, i.e., a network exhibiting churn with nodes and edges entering and leaving the system.Indeed, it is a fundamental problem to scalably build dynamic topologies that have the desirable properties of an expander graph (constant degree and expansion, regardless of the network size) in a distributed manner such that the expander properties are always maintained despite continuous network changes.Hence it is of both theoretical and practical interest to maintain expanders dynamically in an efficient manner.
Many previous works (e.g., [23,18,10]) have addressed the above problem, especially in the context of building dynamic P2P (peer-to-peer) networks.However, all these constructions provide only probabilistic guarantees of the expansion properties that degrade rapidly over a series of network changes (insertions and/or deletions of nodes/edges) -in the sense that expansion properties cannot be maintained ad infinitum due to their probabilistic nature 1 which can be a major drawback in a dynamic setting.In fact, the expansion properties can degrade even more rapidly under adversarial insertions and deletions (e.g., as in [18]).Hence, in a dynamic setting, guaranteed expander constructions are needed.Furthermore, it is important that the network maintains its expander properties (such as high conductance, robustness to failures, and fault-tolerant multi-path routing) efficiently even under dynamic network changes.This will be useful in efficiently building good overlay and P2P network topologies with expansion guarantees that do not degrade with time, unlike the above approaches.
Self-healing is a responsive approach to fault-tolerance, in the sense that it responds to an attack (or component failure) by changing the topology of the network.This approach works irrespective of the initial state of the network, and is thus orthogonal and complementary to traditional non-responsive techniques.Self-healing assumes the network to be reconfigurable (e.g.P2P, wireless mesh, and ad-hoc networks), in the sense that changes to the topology of the network can be made on the fly.Our goal is to design an efficient distributed self-healing algorithm that maintains an expander despite attacks from an adversary.Our Model: We use the self-healing model which is similar to the model introduced in [12,29] and is briefly described here (the detailed model is described in Sec. 2).We assume an adversary that repeatedly attacks the network.This adversary is adaptive and knows the network topology and our algorithm (and also previous insertions/deletions and all previous random choices), and it has the ability to delete arbitrary nodes from the network or insert a new node in the system which it can connect to any subset of nodes currently in the system.We also assume that the adversary can only delete or insert a single node at a time step.The neighbors of the deleted or inserted node are aware of the attack in the same time step and the self-healing algorithm responds by adding or dropping edges (i.e.connections) between nodes.The computation of the algorithm proceeds in synchronous rounds and we assume that the adversary does not perform any more changes until the algorithm has finished its response.As typical in self-healing (see e.g.[12,24,29]), we assume that no other insertion/deletion takes place during the repair phase2 (though our algorithm can be potentially extended to handle such a scenario).The goal is to minimize the number of distributed rounds taken by the self-healing algorithm to heal the network.Our Contributions: In this paper, we present DEX, in our knowledge the first distributed algorithm to efficiently construct and dynamically maintain a constant degree expander network (under both insertions and deletions) under an all-powerful adaptive adversary.Unlike previous constructions (e.g., [23,18,10,2,15]), the expansion properties always hold, i.e., the algorithm guarantees that the dynamic network always has a constant spectral gap (for some fixed absolute constant) despite continuous network changes, and has constant degree, and hence is a (sparse) expander.The maintenance overhead of DEX is very low.It uses Note that the above bounds hold w.h.p. for every insertion/deletion (i.e., in a worst case sense) and not just in an amortized sense.Our algorithm can be extended to handle multiple insertions/deletions per step in the appendix (cf.Appendix B).We also describe (cf.Sec.4.4.4)how to implement a distributed hashtable (DHT) on top of our algorithm DEX, which provides insertion and lookup operations using O(log n) messages and rounds.
Our results answer some open questions raised in prior work.In [10], the authors ask: Can one can design a fully decentralized construction of dynamic expander topologies with constant overhead?The expander maintenance algorithms of [10] and [18] handle deletions much less effectively than additions; [10] also raises the question of handling deletions as effectively as insertions.Our algorithm handles even adversarial deletions as effectively as insertions.Technical Contributions: Our approach differs from previous approaches to expander maintenance (e.g., [18,23,10]).Our approach simulates a virtual network (cf.Sec.3.1) on the actual (real) network.At a high level, DEX works by stepping between instances of the guaranteed expander networks (of different sizes as required) in the virtual graph.It maintains a balanced mapping (cf.Def. 2) between the two networks with the guarantee that the spectral properties and degrees of both are similar.The virtual network is maintained as a p-cycle expander (cf.Def. 1).Since the adversary is fully adaptive with complete knowledge of topology and past random choices, it is non-trivial to efficiently maintain both constant degree and constant spectral gap of the virtual graph.Our maintenance algorithm DEX uses randomization to defeat the adversary and exploits various key algorithmic properties of expanders, in particular, Chernoff-like concentration bounds for random walks ( [9]), fast (almost) uniform sampling, efficient permutation routing ( [28]), and the relationship between edge expansion and spectral gap as stated by the Cheeger Inequality (cf.Theorem 2 in App.A).Moreover, we use certain structural properties of the p-cycle and staggering of "complex" steps that require more involved recovery operations over multiple "simple" steps to achieve worst case O(log n) complexity bounds.It is technically and conceptually much more convenient to work on the (regular) virtual network and this can be a useful algorithmic paradigm in handling other dynamic problems as well.Related Work and Comparison: Expanders are a very important class of graphs that have applications in various areas of computer science (e.g., see [14] for a survey) e.g. in distributed networks, expanders are used for solving distributed agreement problems efficiently [16,3].In distributed dynamic networks (cf.[3]) it is particularly important that the expansion does not degrade over time.There are many well known (centralized) expander construction techniques see e.g., [14]) .
As stated earlier, there are a few other works addressing the problem of distributed expander construction; however all of these are randomized and the expansion properties hold with probabilistic guarantees only.Figure 3 compares our algorithm with some known distributed expander construction algorithms.[18] give a construction where an expander is constructed by composing a small number of random Hamiltonian cycles.The probabilistic guarantees provided degrade rapidly, especially under adversarial deletions.
[10] builds on the algorithm of [18] and makes use of random walks to add new peers with only constant overhead.However, it is not a fully decentralized algorithm.Both these algorithms handle insertions much better than deletions.Spanders [8] is a self-stabilizing construction of an expander network that is a spanner of the graph.[6] shows a way of constructing random regular graphs (which are good expanders, w.h.p.) by performing a series of random 'flip' operations on the graph's edges.[26] maintains an almost d-regular graph, i.e. with degrees varying around d, using uniform sampling to select, for each node, a set of expanderneighbors.The protocol of [23] gives a distributed algorithm for maintaining a sparse random graph under a stochastic model of insertions and deletions.[20] gives a dynamic overlay construction that is empirically shown to resemble a random k-regular graph and hence is a good expander.[11] gives a gossip-based membership protocol for maintaining an overlay in a dynamic network that under certain circumstances provides an expander.
In a model similar to ours, [17] maintains a DHT (Distributed Hash Table ) in the setting where an adaptive adversary can add/remove O(log n) peers per step.Another paper which considers node joins/leaves is [15] which constructs a SKIP+ graph within O(log 2 n) rounds starting from any graph whp.Then, they also show that after an insert/delete operation the system recovers within O(log n) steps (like ours, which also needs O(log n) steps whp) and with O(log4 n) messages (while ours takes O(log n) messages whp).However, the SKIP+ graph has an additional advantage that it is self-stabilizing, i.e., can recover from any initial state (as long as it is weakly connected).[15] assume (as do we) that the adversary rests while the network converges to a SKIP+ graph.It was shown in [2] that skip graphs contain expanders as subgraphs w.h.p., which can be used as a randomized expander construction.Skip graphs (and its variant SKIP+ [15]) are probabilistic structures (i.e., their expansion holds only with high probability) and furthermore, they are not of constant degree, their degree grows logarithmic in the network size.The work of [22] has guaranteed expansion (like ours).However, as pointed out in [2], its main drawback (unlike ours) is that their algorithm has a rather large overhead in maintaining the network.
A variety of self-healing algorithms deal with maintaining topological invariants on arbitrary graphs [12,24,29,13,27].The self-healing algorithm Xheal of [24] maintains spectral properties of the network (while allowing only a small increase in stretch and degree), but it relied on a randomized expander construction and hence the spectral properties degraded rapidly.Using our algorithm as a subroutine, Xheal can be efficiently implemented with guaranteed spectral properties.

The Self-Healing Model
The model we are using is similar to the models used in [12,24].We now describe the details.Let G = G 0 be a small arbitrary graph 3 where nodes represent processors in a distributed network and edges represent the links between them.Each step t 1 is triggered by a deletion or insertion of a single 4 node from G t−1 by the adversary, yielding an intermediate network graph U t .The neighbors of the (inserted or deleted) node in the network U t react to this change by adding or removing edges in U t , yielding G t -this is called recovery or repair.The distributed computation during recovery is structured into synchronous rounds.We assume that the adversary rests until the recovery is complete, and subsequently triggers the next step by inserting/deleting a node.During recovery, nodes can communicate with their neighbors by sending messages of size O(log n), which are neither lost nor corrupted.We assume that local computation (within a node) is free, which is a standard assumption in distributed computing (e.g.[25]).Our focus is only on the cost of communication (time and messages).
Initially, a newly inserted node v only knows its unique id (chosen by the adversary) and does not have $ n 0 is the initial network size.Parameter d = # of Hamiltonian cycles in 'healing' graph (H).‡ Costs given under certain assumptions about key length.!Skip+ is a self-stabilizing structure but costs here are for single join/leave operations once a valid skip+ graph is achieved.any a priori knowledge of its neighbors or the current network topology.In particular, this means that a node u can only add an edge to a node w if it knows the id of w.
In case of an insertion, we assume that the newly added node is initially connected to a constant number of other nodes.This is merely a simplification; nodes are not malicious but faithfully follow the algorithm, thus we could explicitly require our algorithm to immediately drop all but a constant number of edges.The adversary is fully adaptive and is aware of our algorithm, the complete state of the current network including all past random choices.As typically the case (see e.g.[12,24]), we assume that no other node is deleted or inserted until the current step has concluded (though our algorithm can be modified to handle such a scenario).

Preliminaries and Overview of Algorithm DEX
It is instructive to first consider the following natural (but inefficient) algorithms: Flooding: First, we consider a naive flooding-based algorithm that also achieves guaranteed expansion and node degree bounds, albeit at a much larger cost: Whenever a node is inserted (or deleted), a neighboring node floods a notification throughout the entire network and every node, having complete knowledge of the current network graph, locally recomputes the new expander topology.While this achieves a logarithmic runtime bound, it comes at the cost of using Θ(n) messages in every step and, in addition, might also result in O(n) topology changes, whereas our algorithms requires only polylogarithmic number of messages and constant topology changes on average.Maintaining Global Knowledge: As a second example of a straightforward but inefficient solution, consider the algorithm that maintains a global knowledge at some node p, which keeps track of the entire network topology.Thus, every time some node u is inserted or deleted, the neighbors of u inform p of this change, and p then proceeds to update the current graph using its global knowledge.However, when p itself is deleted, we would need to transfer all of its knowledge to a neighboring node q, which then takes over p's role.This, however, requires at least Ω(n) rounds, since the entire knowledge of the network topology needs to be transmitted to q.Our Approach -Algorithm DEX: As mentioned in Sec. 2, the actual (real) network is represented by a graph where nodes correspond to processors and edges to connections.Our algorithm maintains a second graph, which we call the virtual graph where the vertices do not directly correspond to the real network but each (virtual) vertex in this graph is simulated by a (real) node 5 in the network.The topology of the virtual graph determines the connections in the actual network.For example, suppose that node u simulates vertex z 1 and node v simulates vertex z 2 .If there is an edge (z 1 , z 2 ) according to the virtual graph, then our algorithm maintains an edge between u and v in the actual network.In other words, a real node may be simulating multiple virtual vertices and maintaining their edges according to the virtual graph.
Figure 2 on page 6 shows a real network (on the right) whose nodes (shaded rectangles) simulate the virtual vertices of the virtual graph (on the left).In our algorithm, we maintain this virtual graph and show that preserving certain desired properties (in particular, constant expansion and degree) in the virtual graph leads to these properties being preserved in the real network.Our algorithm achieves this by maintaining a "balanced load mapping" (cf.Def. 3) between the virtual vertices and the real nodes as the network size changes at the will of the adversary.The balanced load mapping keeps the number of virtual nodes simulated by any real node to be a constant -this is crucial in maintaining the constant degree bound.We next formalize the notions of virtual graphs and balanced mappings.Consider some graph G and let λ G denote the second largest eigenvalue of the adjacency matrix of G.The contraction of vertices z 1 and z 2 produces a graph H where z 1 are z 2 merged into a single vertex z that is adjacent to all vertices to which z 1 or z 2 were adjacent in G.We extensively make use of the fact that this operation leaves the spectral gap 1 − λ G intact, cf.Lem. 10 in App. A.

Virtual Graphs and Balanced Mappings
As mentioned earlier, our virtual graph consists of virtual vertices simulated by real nodes.Intuitively speaking, we can think of a real node simulating z 1 and z 2 as a vertex contraction of z 1 and z 2 .The above stated contraction property motivates us to use an expander family (cf.Def. 4 in App.A) as virtual graphs.We now define the p-cycle expander family, which we use as virtual graphs in this paper.Essentially, we can think of a p-cycle as a numbered cycle with some chord-edges between numbers that are multiplicative inverses of each other.It was shown in [19] that this yields an infinite family of 3-regular expander graphs with a constant eigenvalue gap. Figure 2 shows a 23-cycle.
Definition 1 (p-cycle, cf.[14]) For any prime number p, we define the following graph Z(p).The vertex set of Z(p) is the set Z p = {0, . . ., p − 1} and there is an edge between vertices x and y if and only if one of the following conditions hold: (1) y = (x + 1) mod p, (2) y = (x − 1) mod p, or (3) if x, y > 0 and y = x −1 .Moreover, vertex 0 has a self-loop.
At any point in time t, our algorithm maintains a mapping from the virtual vertices of a p-cycle to the actual network nodes.We use the notation Z t (p) when Z(p) is the p-cycle that we are using for our mapping in step t. (We omit p and simply write Z t if p is irrelevant or clear from the context.)At any time t, each real node simulates at least one virtual vertex (i.e. a vertex in the p-cycle) and all its incident edges as required by Def. 1, i.e., the real network can be considered a contraction of the virtual graph; see Figure 2 on page 6 for an example.Formally, this defines a function that we call a virtual mapping: Definition 2 (Virtual mapping) For step t 1, consider a surjective map Φ t : V (Z t ) → V (G t ) that maps every virtual vertex of the virtual graph Z t to some (real) node of the network graph G t .Suppose that there is an edge (Φ t (z 1 ), Φ t (z 2 )) ∈ E(G t ) if and only if there is an edge (z 1 , z 2 ) ∈ E(Z t ), for all nodes z 1 , z 2 ∈ V (Z t ).Then we call Φ t a virtual mapping.Moreover, we say that node u ∈ V (G t ) is a real node that simulates virtual vertices In the standard metric spaces on Z t and G t induced by the shortest-path metric Φ is a surjective metric map since distances do not increase: ) denote the length of the shortest path between u and v in graph H. Any virtual mapping Φ t guarantees that dist Zt (z 1 , z 2 ) dist Gt (Φ(z 1 ), Φ(z 2 )), for all z 1 , z 2 ∈ Z t .
We simply write Φ instead of Φ t when t is irrelevant.
We consider the vertices of Z t to be partitioned into disjoint sets of vertices that we call clouds and denote the cloud to which a vertex z belongs as CLOUD(z).Whereas initially we can think of a cloud as the set of virtual vertices simulated at some node in G t , this is not true in general due to load balancing issues, as we discuss in Section 4. We are only interested in virtual mappings where the maximum cloud size is bounded by some universal constant ζ, which is crucial for maintaining a constant node degree.For our p-cycle construction, it holds that ζ 8.
We now formalize the intuition that the expansion of the virtual p-cycle carries over to the network, i.e., the second largest eigenvalue λ Gt of the real network is bounded by λ Zt of the virtual graph.Observe that we can obtain G t from Z t by contracting vertices.That is, we contract vertices z 1 and z 2 if Φ(z 1 ) = Φ(z 2 ).According to Lemma 10, these operations do not increase λ Gt and thus we have shown the following: Lemma 1 Let Φ t : Z t → G t be a virtual mapping.Then it holds that λ Gt λ Zt .
Next we formalize the notion that our real nodes simulate at most a constant number of nodes.Let SIM t (u) = Φ −1 t (u) and define the load of a node u in graph G t as the number of vertices simulated at u, i.e., LOAD t (u) = |SIM t (u)|.Note that due to locality, node u does not necessarily know the mapping of other nodes.Definition 3 (Balanced mapping) Consider a step t.If there exists a constant C s.t.∀u ∈ G t : LOAD t (u) C, then we say that Φ t is a C-balanced virtual mapping and say that G t is C-balanced.
Figure 2 on page 6 shows a balanced virtual mapping.At any step t, the degree of a node u ∈ G t is exactly 3.LOAD t (u) since we are using the 3-regular p-cycle as a virtual graph.Thus our algorithm strives to maintain a constant bound on LOAD t (u), for all t.Given a virtual mapping Φ t , we define the (not necessarily disjoint) sets (1) Intuitively speaking, LOW t contains nodes that do not simulate too many virtual vertices, i.e., have relatively low degree, whereas SPARE t is the set of nodes that simulate at least 2 vertices each.When the adversary deletes some node u, we need to find a node in LOW t that takes over the load of u.Upon a node v being inserted, on the other hand, we need to find a node in SPARE t that can spare a virtual vertex for v, while maintaining the surjective property of the virtual mapping.

Expander Maintenance Algorithm
We describe our maintenance algorithm DEX and prove the performance claims of Theorem 1.We start with a small initial network G 0 of some appropriate constant and assume there is a virtual mapping from a p-cycle Z 0 (p 0 ) where p 0 is the smallest prime number in the range (4n 0 , 8n 0 ).The existence of p 0 is guaranteed by Bertrand's postulate [4].(Since G 0 is of constant size, nodes can compute the current network size n 0 and Z 0 (p 0 ) in a constant number of rounds in a centralized manner.)Starting out from this initial expander, we seek to guarantee expansion ad infinitum, for any number of adversarial insertions and deletions.We always maintain the invariant that each real node simulates at least one (i.e. the virtual mapping is surjective) and at most a constant number of virtual p-cycle vertices.The adversary can either insert or delete a node in every step.In either case, our algorithm reacts by doing an appropriate redistribution of the virtual vertices to the real nodes with the goal of maintaining a C-balanced mapping (cf.Definition 3).
Depending on the operations employed by the algorithm, we classify the response of the algorithm for a given step t as being either a type-1 recovery or a type-2 recovery and call t a type-1 recovery step (resp.type-2 recovery step).Type-1 recovery is very efficient, as (w.h.p.) it suffices to execute a single random walk of O(log n) length.
It is somewhat more complicated to show a worst case O(log n) performance for type-2 recovery: Here, the current virtual graph is either inflated or deflated to ensure a C-balanced mapping (i.e.bounded degrees).For the sake of exposition, we first present a simpler way to handle inflation and deflation, which yields amortized complexity bounds.We then describe a more complicated algorithm for type-2 recovery that yields the claimed worst case complexity bounds of O(log n) rounds and messages, and O(1) topology changes per step with high probability.The first (simplified) approach (cf.Sec.4.2) replaces the entire virtual graph by a new virtual graph of appropriate size in a single step.This requires O(n) topology changes and O(n log 2 n) message complexity, because all nodes complete the inflation/deflation in one step.Since there are at least Ω(n) steps with type-1 recovery between any two steps where inflation or deflation is necessary, we can nevertheless amortize their cost and get the amortized performance bounds of O(log n) rounds and O(log 2 n) messages (cf.Cor. 1).We then present an improved (but significantly more complex) way of handling inflation (resp.deflation), by staggering these inflation/deflation operations across the recovery of the next Θ(n) following steps while retaining constant expansion and node degrees.This yields a O(log n) worst case bounds for both messages and rounds for all steps as claimed by Theorem 1.In terms of expansion, the (amortized) inflation/deflation approach yields a spectral gap no smaller than of the p-cycle, the improved worst case bounds of the 2nd approach come at the price of a slightly reduced, but still constant, spectral gap.Algorithm A.1 presents a high-level pseudo code description of our approach.

Type-1 Recovery
When a node u is inserted, a neighboring node v initiates a random walk of length at most Θ(log n) to find a "spare" virtual vertex, i.e., a virtual vertex z that is simulated by a node w ∈ SPARE G t−1 (see Algorithm A.2 for the detailed pseudo code).Assigning this virtual vertex z to the new node u, ensures a surjective mapping of virtual vertices to real nodes at the end of the step.
When a node u is deleted, on the other hand, the notified neighboring node v also initiates random walks, except this time with the aim of redistributing the deleted node u's virtual vertices to the remaining real nodes in the system(cf.Algorithm A.3).We assume that every node v has knowledge of LOAD G t−1 (w), for each of its neighbors u. (This can be implemented with constant overhead, by simply updating neighboring nodes when the respective LOAD G t−1 changes.)Since the deleted node u might have simulated multiple vertices, node v initiates a random walk for each z ∈ LOAD G t−1 (u), to find a node w ∈ LOW G t−1 to take over virtual vertex z.In a nutshell, type-1 recovery consists of (re)balancing the load of virtual vertices to real nodes by performing random walks.Rebalancing the load of a deleted node succeeds with high probability, as long as θn nodes are in LOW G t−1 , where the rebuilding parameter θ is a fixed constant.For our analysis, we require that θ 1/(68ζ + 1), where ζ 8 is the maximum (constant) cloud size given by the p-cycle construction.Analogously, for insertion steps, finding a spare vertex will succeed w.h.p. if SPARE G t−1 has size θn.If the size is below θn, we handle the insertion (resp.deletion) by performing an inflation (resp.deflation) as explained below.Thus we formally define a step t to be a type-1 step, if either (1) a node is inserted in t and If a random walk fails to find an appropriate node, we do not directly start an inflation resp.deflation, but first deterministically count the network size and sizes of SPARE G t−1 and LOW G t−1 by simple aggregate flooding (cf.Procedures computeLow and computeSpare).We repeat the random walks, if it turns out that the respective set indeed comprises θn nodes.As we will see below, this allows us to deterministically guarantee constant node degrees.The following lemma shows an O(log n) bound for messages and rounds used by random walks in type-1 recovery: Lemma 2 Consider a step t and suppose that Φ t−1 is a 4ζ-balanced virtual map.There exists a constant such that the following hold w.h.p: (a) If |SPARE G t−1 | θn and a new node u is attached to some node v, then the random walk initiated by v reaches a node in θn and some node u is deleted, then, for each of the (at most 4ζ ∈ O(1)) vertices simulated at u, the initiated random walk reaches a node in SPARE G t−1 in log n rounds.That is, w.h.p. type-1 recovery succeeds in O(log n) messages and rounds, and a constant number of edges are changed.
Proof.We will first consider the case where a node is deleted (Case (b)).The main idea of the proof is to instantiate a concentration bound for random walks on expander graphs [9].By assumption, the mapping of virtual vertices to real nodes is 4ζ-balanced before the deletion occurs.Thus we only need to redistribute a constant number of virtual vertices when a node is deleted.
We now present the detailed argument.By assumption we have that |LOW| = an θn, for a constant 0 < a < 1.We start a random walk of length log n for some appropriately chosen constant (determined below).We need to show that (w.h.p.) the walk hits a node in LOW.According to the description of type-1 recovery for handling deletions, we perform the random walk on the graph G t , which modifies G t−1 \ {u}, by transferring all virtual vertices (and edges) of the deleted node u to the neighbor v. Thus, for the second largest eigenvalue λ = λ G t , we know by Lemma 1 that λ λ G t−1 .Consider the normalized n × n adjacency matrix M of G t .It is well known (e.g., Theorem 7.13 in [21]) that a vector π corresponding to the stationary distribution of a random walk on G t−1 has entries π(x) = dx 2|E(G t )| where d x is the degree of node x.By assumption, the network G t−1 is the image of a 4ζ-balanced virtual map.This means that the maximum degree ∆ of any node in the network is ∆ 12ζ, and since the p-cycle is a 3-regular expander, every node has degree at least 3.If the adversary deletes some node in step t, the maximum degree of one of its neighbors can increase by at most ∆.Therefore, the maximum degree in U t and thus G t is bounded by 2∆, which gives us the bound π(x) 3/(2∆n), for any node x ∈ G t .Let ρ be the actual number of nodes in LOW that the random walk of length log n hits.We define q to be an n-dimensional vector that is 0 everywhere except at the index of u in M where it is 1.Let E be the event that log n • π(LOW) − ρ γ, for a fixed γ 0. That is, E occurs if the number of nodes in LOW visited by the random walk is far away ( γ) from its expectation.
In the remainder of the proof, we show that E occurs with very small probability.Applying the concentration bound of [9] yields that where q/ √ π is a vector with entries (q/ √ π)(x) = q(x)/ π(x), for 1 x n.By (4), we know that π(LOW) 3a/2∆.To guarantee that we find a node in LOW w.h.p. even when π(LOW) is small, we must set γ = 3a 2∆ log n.Moreover, (4) also gives us the bound ||q/ . To ensure that event E happens with small probability, it is sufficient if the exponent of n is smaller than −C, which is true for sufficiently large .Since θ, ∆, and the spectral gap 1 − λ are all O(1), it follows that is a constant too and thus the running time of one random walk is O(log n) with high probability.Recall that node v needs to perform a random walk for each of the virtual vertices that were previously simulated by the deleted node u; there are at most 4ζ ∈ O(1) such vertices, since we assumed that Φ t−1 is 4ζ balanced.Therefore, all random walks take O(log n) rounds in total (w.h.p.).Now consider Case (a), i.e., the adversary inserted a new node u and attached it to some existing node v.By assumption, |SPARE| = an θn, and the random walk is executed on the graph G t−1 (excluding newly inserted node u).Thus (4) and the remaining analysis hold analogously to Case (b), which shows that the walk reaches a node in SPARE in O(log n) rounds (w.h.p.).
Note that we only transfer a constant number of virtual vertices to a new nodes in type-1 recovery steps, i.e., the number of topology changes is constant.
The following lemma summarizes the properties that hold after performing a type-1 recovery: Proof.For (a), we first argue that the mapping Φ t is surjective: This follows readily from the above description of type-1 recovery (see insertion(u, θ) and deletion(u, θ) for the full pseudo code): In the case of a newly inserted node, the algorithm repeatedly performs a random walk until it finds a node in SPARE since |SPARE| θn.If some node u is deleted, then a neighbor initiates random walks to find a new host for each of u's virtual vertices, until it succeeds.Thus, at the end of step t, every node simulates at least 1 virtual vertex.To see that no node simulates more than 4ζ vertices, observe that the load of a node can only increase due to a deletion.As we argued above, however, the neighbor v that temporarily took over the virtual vertices of the deleted node u, will attempt to spread these vertices to nodes that are in LOW and is guaranteed to eventually find such nodes by repeatedely performing random walks.Properties (b), (c), and (d) follow from Lemma 2.

Type-2 Recovery: Inflating and Deflating
We now describe an implementation of type-2 recovery that yields amortized polylogarithmic bounds on messages and time.We later extend these ideas (cf.Sec.For simplicity, we use x to denote both: an integer x ∈ Z p and also the associated vertex in V (Z t (p)).At the beginning of step t, all nodes are in agreement on the current virtual graph Z t−1 (p i ), in particular, every node knows the prime number p i .To get a larger p-cycle, all nodes deterministically compute the (same) smallest prime number p i+1 ∈ (4p i , 8p i ), i.e., V (Z t (p i+1 )) = Z p i+1 .(Local computation happens instantaneously and does not incur any cost (cf.Sec.2).) Bertrand's postulate [4] states that for every n > 1, there is a prime between n and 2n, which ensures that p i+1 exists.Every node u needs to determine the new set of vertices in Z t (p i+1 ) that it is going to simulate: Let α = p i+1 p i ∈ O(1).For every currently simulated vertex x ∈ SIM G t−1 (u), node u computes the constant and replaces x with the new virtual vertices y 0 , . . ., y c(x) where Note that the vertices y 0 , . . ., y c(x) form a cloud (cf.Sec.3.1) where the maximum cloud size is ζ 8.This ensures that the new virtual vertex set is a bijective mapping of Z p i+1 .Next, we describe how we find the edges of Z t (p i+1 ): First, we add new cycle edges (i.e.edges between x and x + 1 mod p i+1 ), which can be done in constant time by using the cycle edges of the previous virtual graph Z t−1 (p i ).For every x that u simulates, we need to add an edge to the node that simulates vertex x −1 .Since this needs to be done by the respective simulating node of every virtual vertex, this corresponds to solving a permutation routing instance.Corollary 7.7.3 of [28] (cf.Corollary 2) states that, for any bounded degree expander with n nodes, n packets, one per node, can be routed (even online) according to an arbitrary permutation in O( log n(log log n) 2 log log log n ) rounds w.h.p.Note that every node in the network knows the exact topology of the current virtual graph (but not necessarily of the network graph G t ), and can hence calculate all routing paths in this graph, which map to paths in the actual network (cf.Fact 1).Since every node simulates a constant number of vertices, we can find the route to the respective inverse by solving a constant number of permutation routing instances.The following lemma follows from the previous discussion: Lemma 4 Consider a t 1 where some node performs type-2 recovery via simplifiedInfl.If the network graph G t−1 is a C-balanced image of Z t−1 (p i ), then Phase 1 of simplifiedInfl ensures that every node computes the same virtual graph in O(log n(log log n) 2 ) rounds such that the following hold: (a) Proof.Property (a) follows from the previous discussion.For Property (b), we first show set equivalence.Consider any z ∈ Z p i+1 and assume in contradiction that z / ∈ V (Z t (p i+1 )).Let α = p i+1 /p i and let x be the greatest integer such that z = αx + k, for some integer k 0. If k α, then which contradicts the maximality of x, therefore, we have that k < α.It cannot be that x < p i , since otherwise z ∈ V (Z(p i+1 )) according to (7), which shows that x p i .This means that To complete the proof of (b), we need to show that no two distinct vertices in V (Z t (p i+1 )) correspond to the same value in Z p i+1 , i.e., V (Z t (p i+1 )) is not a multi-set.Suppose, for the sake of a contradiction, that there are y = ( αx + k) mod p i+1 and y = ( αx + k ) mod p i+1 with y = y .By (7), we know that k c(x), hence to bound k it is sufficient to show that c(x) < α: By (6), we have that Note that the same argument shows that k α.Thus it cannot be that y = αx + k + mp i+1 , for some integer m 1.This means that x = x ; wlog assume that x > x .As we have shown above, k c(x) < α, which implies that y = αx + k < α(x + 1) αx y, yielding a contradiction to y = y .For property (c), observe that all new cycle edges (i.e., of the form (x, x ± 1)) of Z t (p i+1 ) are between nodes that were already simulating neighboring vertices of Z t−1 (p i ), thus every node u can add these edges in constant time.Finally, we argue that every node can efficiently find the inverse vertex for its newly simulated vertices: Corollary 7.7.3 of [28] states that for any bounded degree expander with n nodes, n packets, one per processor, can be routed (online) according to an arbitrary permutation in T = O( log n(log log n) 2 log log log n ) rounds w.h.p.Note that every node in the network knows the exact topology of the current virtual graph (nodes do not necessarily know the network graph G t !), and can hence calculate all routing paths, which map to paths in the actual network (cf.Fact 1).Since every node simulates a constant number of vertices, we can find the route to the respective inverse by performing a constant number of iterations of permutation routing, each of which takes T rounds.
Phase 2: Rebalancing the Load Once the new virtual graph Z t (p i+1 ) is in place, each real node simulates a greater number (by a factor of at most ζ) of virtual vertices and now a random walk is guaranteed to find a spare virtual vertex on the first attempt with high probability, according to Lemma 2.(a).At the beginning of the step, the virtual mapping Φ t−1 was 4ζ-balanced.This, however, is not necessarily the case after Phase 1, i.e., replacing Z t−1 by Z t .A node could have been simulating 4ζ virtual vertices before simplifiedInfl was invoked and now might be simulating 4ζ 2 vertices of Z t (p i+1 ).In fact, this can be the case for a θ-fraction of the nodes.To ensure a 4ζ-balanced mapping at the end of step t, we thus need to rebalance these additional vertices among the other (real) nodes.Note that this is always possible, since (1 − θ)n nodes had a load of 1 before invoking simplifiedInfl and simulate only ζ virtual vertices each at the end of Phase 1.A node v that has a load of k > 4ζ vertices of Z t (p i+1 ), proceeds as follows, for each vertex z of the (at most constant) vertices that it needs to redistribute: Node v marks all of its vertices as full and initiates a random walk of length Θ(log n) on the virtual graph Z t (p i+1 ), which is simulated on the actual network.If the walk ends at a vertex z simulated at some node w that is not marked as full, and no other random walk simultaneously ended up at z , then v transfers z to w.This ensures that z is now simulated at a node that had a load of < 4ζ.A node w immediately marks all of its vertices as full, once its load reaches 2ζ.Node v repeatedly performs random walks until all of the k − 4ζ vertices are transfered to other nodes.Proof.Here we will show the result for simplifiedInfl.In Sec.4.2.2, we will argue the same properties for simplifiedDefl (described below).Property (d) follows readily from the description of Phase 1.For (a), we observe that, in Phase 1, simplifiedInfl replaces each virtual vertex with a cloud of virtual vertices.Moreover, nodes only redistribute vertices such that their load does not exceed 4ζ.It follows that every node simulates at least one vertex, thus Φ t is surjective.What remains to be shown is that every node has a load 4ζ at the end of t.
Consider any node u that has LOAD(v) ∈ (2ζ, 4ζ) after Phase 1.To see that u's load does not exceed 4ζ, recall that, according the description of Phase 2, u will mark all its vertices as full and henceforth will not accept any new vertices.By Fact 2.(a), at most θn nodes have a load > 1 in U t .Let Balls 0 be the set of vertices that need to be redistributed.Lemma 4.(a) tells us that the every vertex in Z t−1 (p i ) is replaced by (at most) ζ new vertices in Z t (p i+1 ), which means that |Balls 0 | 4θ(ζ 2 − ζ)n, since every such high-load node continues to simulate 4ζ vertices by itself.
To ensure that this redistribution can be done in polylogarithmic time, we need to lower bound the total number of available places (i.e. the bins) for these virtual vertices (i.e. the balls).By Fact 2.(a), we know that (1 − θ)n nodes have a load of at most ζ after Phase 1.These nodes do not mark their vertices as full, and thus accept to simulate additional vertices until their respective load reaches 2ζ.Let Bins be the set of virtual vertices that are not marked as full; It holds that |Bins| (1 − θ)ζn.
We first show that with high probability, a constant fraction of random walks end up at vertices in |Bins|.Since Z t (p i+1 ) is a regular expander, the distribution of the random walk converges to the uniform distribution (e.g., [21]) within O(log σ) random steps where σ = |Z i+1 | ∈ Θ(n).More specifically, the distance (measured in the maximum norm) to the uniform distribution, represented by a vector (1/σ, . . ., 1/σ), can be bounded by 1 100σ .Therefore, the probability for a random walk token to end up at a specific vertex is within [ 99 100σ , 101 100σ ].Recall that, after Phase 1 all nodes have computed the same graph Z t (p i+1 ) and thus use the same value σ.
We divide the random walks into epochs where an epoch is the smallest interval of rounds containing c log n random walks.We denote the number of vertices that still need to be redistributed at the beginning of epoch i as Balls i .Proof.We will now show that an epoch lasts at most O(log 3 n) rounds with high probability.First, suppose that |Balls i | c log n.By Lemma 11, we know that even a linear number of parallel walks (each of length Θ(log n)) will complete within O(log 2 n) rounds w.h.p.Therefore, epoch i consists of O(log 2 n) rounds, since Ω(log n) random walks are performed in parallel.In the case where |Balls j | < c log n, it is possible that an epoch consists of random walks that are mostly performed sequentially by the same nodes.Thus we add a log n factor to ensure that epoch j consists of c log n walks.By Lemma 11 we get a bound of O(log 3 n) rounds.
Next, we will argue that after O(log n) epochs, we have |Balls j | < c log n.Thus consider any epoch i where |Balls i | c log n.We bound the probability of the indicator random variable Y k that is 1 iff the walk associated with the k-th vertex ends up at a vertex that was already marked full when the walk was initiated.(In particular, Y k = 0 if the k-th walk ends up at z and z became full in the current iteration but was not marked full before.)Note that all Y k are independent.While the number of available bins (i.e.non-full vertices) will decrease over time, we know from ( 3 , thus with high probability (in n), a constant fraction of the random walks in epoch i will end up at non-full vertices.We call these walks good balls and denote this set as Good i .
We will now show that a constant fraction of good balls do not end up at the same bin with high probability, i.e., we are able to successfully redistribute the associated vertices in this epoch.Let X k be the indicator random variable that is 1 iff the k-th ball is eliminated.We have Pr (1) , i.e., at least a constant fraction of the balls in Good i are eliminated on expectation.
Let W denote the number of eliminated vertices in epoch i, which is a function f (B 1 , . . ., B |Good i | ) where B j denotes the bin chosen by the j-th ball.Observe that changing the bin of some ball can affect the elimination of at most one other ball.In other words, W satisfies the Lipschitz condition and we can apply the method of bounded differences.By the Azuma-Hoeffding Inequality (cf.Theorem 12.6 in [21]), we get a sharp concentration bound for W , i.e., with high probability, a constant fraction of the balls are eliminated in every epoch.
We have therefore shown that after O(log n) epochs, we are left with less than c log n vertices that need to be redistributed, w.h.p.Let j be the first epoch when |Balls j | < c log n.Note that epoch j consists of Ω(log n) random walks where some nodes perform multiple random walks.By the same argument as above, we can show that with high probability, a constant fraction of these walks will end up at some nonfull vertices without conflicting with another walk and are thus eliminated.Since we only need c log n walks to succeed, this ensures that the entire set Balls j is redistributed w.h.p. by the end of epoch j, which shows (a).
By Claim 1, the first O(log n) epochs can each last O(log 2 n) rounds, while only epoch j takes O(log 3 n) rounds.Altogether, this gives a running time bound of O(log 3 n), as required for (b).For Property (c), note that the flooding of the inflation request to all nodes in the network requires O(n) messages.This, however, is dominated by the time it takes to redistribute the load: each epoch might use O(n log n) messages.Since we are done w.h.p. in O(log n) epochs, we get a total message complexity of O(n log 2 n).For (d), observe that the sizes of the virtual expanders Z t−1 (p i ) and Z t (p i+1 ) are both in O(n).Due to their constant degrees, at most O(n) edges are affected by replacing the edges of Z t−1 (p i ) with the ones of Z t (p i+1 , yielding a total of O(n) topology changes for) simplifiedInfl.

Deflating the Virtual Graph
When the load of all but θn nodes exceeds 2ζ and some node u is deleted, the high probability bound of Lemma 2 for the random walk invoked by neighbor v no longer applies.In that case, node v invokes Procedure simplifiedDefl to reduce the overall load (cf.Algorithm A.6). Analogously as simplifiedInfl, Procedure simplifiedDefl consists of two phases: Phase 1: Constructing a Smaller p-Cycle To reduce the load of simulated vertices, we replace the current p-cycle Z t−1 (p i ) with a smaller p-cycle Z t (p s ) where p s is a prime number in the range (p i /8, p i /4).
Let α = p i /p s .Any virtual vertex x ∈ Z t−1 (p i ), is (surjectively) mapped to some y x ∈ Z t (p s ) where y = x/α .Note that we only add y to V (Z t (p s )) if there is no smaller x ∈ Z t−1 (p i ) that yields the same y.This mapping guarantees that, for any element in Z ps , we have exactly 1 virtual vertex in Z t (p s ): Suppose that there is some y ∈ Z ps that is not hit by our mapping, i.e., for all x ∈ Z p i , we have y > x α .Let x be the smallest integer such that y = x α .For such an x , it must hold that αy x < α(y + 1).Since α > 1, clearly x exists.By assumption, we have x p i , which yields p i /α x /α = y < p s .Since p s = p i /α, we get p s < p s , which is a contradiction to p s ∈ N. Therefore, we have shown that Z s ⊆ V (Z t (p s )).The opposite set inclusion can be shown similarly.
For computing the edges of Z t (p s ), note that any cycle edge (y, y ± 1) ∈ E(Z t (p s )), is between nodes u and v that were at most α hops apart in G t , since their distance is at most α in the virtual graph Z t−1 (p i ).Thus any such edge can be added by exploring a neighborhood of constant-size in O(1) rounds via the cycle edges (of the current virtual graph) Z t−1 (p i ) in G t .To add the edge between y and its inverse y −1 , we proceed along the lines of Phase 1 of simplifiedInfl, i.e., we solve permutation routing on Z t−1 (p i ), taking O( log n(log log n) 2 log log log n ) rounds.The following lemma summarizes the properties of Phase 1: Proof.Property (a) trivially holds.For (b), observe that by description Phase 1, we map x ∈ Z t−1 (p i ) surjectively to y x ∈ Z t (p s ) using the mapping y x = x α where α = p i ps .Note that we only add y x to V (Z t (p s )) if there is no smaller x ∈ Z t−1 (p i ) that yields the same value in Z ps , which guarantees that V (Z t (p s )) is not a multiset.Suppose that there is some y ∈ Z ps that is not hit by our mapping, i.e., for all x ∈ Z p i , we have y > x α .Let x be the smallest integer such that y = x α .For such an x , it must hold that αy x < α(y + 1).Since α > 1, clearly x exists.By assumption we have x p i , which yields Since α = p i ps , we get which is a contradiction to p s ∈ N. Therefore, we have shown that Z s ⊆ V (Z t (p s )).To see that V (Z t (p s )) ⊆ Z s , suppose that we add a vertex y p s to V (Z t (p s )).By the description of Phase 1, this means that there is an x ∈ V (Z t−1 (p i )), i.e., x p i − 1, such that y = x α .Substituting for α yields a contradiction to y p s , since For property (c), note that any cycle edge (y, y ± 1) ∈ E(Z t (p s )), is between nodes u and v that were at most α hops apart in G t , since their distance can be at most α in Z t−1 (p i ).Thus any such edge can be added by exploring a neighborhood of constant-size in O(1) rounds via the cycle edges of To add an edge between y and its inverse y −1 , we proceed along the lines of the proof of Lemma 4, i.e., we solve permutation routing on Z t−1 (p i ), taking O( log n(log log n) 2 log log log n ) rounds.
Phase 2: Ensuring a Virtual Mapping After Phase 1 is complete, the replacement of multiple virtual vertices in Z t−1 (p i ) by a single vertex in Z t (p s ), might lead to the case where some nodes are no longer simulating any virtual vertices.A node that currently does not simulate a vertex, marks itself as contending and repeatedly keeps initiating random walks on Z t (p s ) (that are simulated on the actual network graph) to find spare vertices.Moreover, a node w that does simulate vertices, marks an arbitrary vertex as taken and transfers its other vertices to other nodes if requested.To ensure a valid mapping Φ t , we need to transfer non-taken vertices to contending nodes if the random walk of a contending node hits a non-taken vertex z and no other walk ends up at z simultaneously.A similar analysis as for Phase 2 of simplifiedInfl shows Lemma 5 for deflation steps.Lemmas 3 and 5 imply the following: Lemma 7 At any step t, the network graph G t , is 4ζ-balanced, i.e., G t has constant node degree and λ Gt λ where 1 − λ is the spectral gap of the p-cycle expander family.
Proof.The result follows by induction on t.For the base case, note that we initialize G 0 to be a virtual mapping of the expander Z 0 (p 0 ), which obviously guarantees that the network is 4ζ-balanced.For the induction step, we perform a case distinction depending on whether t is a simple or inflation/deflation step and apply the respective result, i.e.Lemmas 3 or 5.

Amortizing (Simplified) Type-2 Recovery
We will now show that the expensive inflation/deflation steps occur rather infrequently.This will allow us to amortize the cost of the worst case bounds derived in Section 4.2.Suppose that step t was an inflation step.By Fact 2.(a), this means that at least (1 − θ)n nodes had a load of 1 at the beginning of t, and thus a load of ζ at the end of t.Thus, even after redistributing the additional load of the θn nodes that might have had a load of > 4ζ, a large fraction of nodes are in LOW and SPARE at the end of t.This guarantees that we perform type-1 recovery in Ω(n) steps, before the next inflation/deflation is carried out.A similar argument applies to the case when simplifiedDefl is invoked, thus yielding amortized polylogarithmic bounds on messages and rounds per every step.
Lemma 8 There exists a constant δ such that the following holds: If t 1 and t 2 are steps where type-2 recovery is performed (via simplifiedInfl or simplifiedDefl), then t 1 and t 2 are separated by at least δn ∈ Ω(n) steps with type-1 recovery where n is the size of G t 1 .
For the proof of Lemma 8 we require the following 2 technical results: Claim 2 Suppose that t is an inflation step.Then |LOW t | (θ + To guarantee the sought bound on SPARE t , we need to show that LOAD(G t ) (1 + θ + 1 4ζ )n.This is true, since by (3) we have θ 1  3 + 1 4ζ .Therefore, by the pigeon hole principle, at least θ + 1 4ζ nodes have a load of at least 2.
Proof.[Proof of Lemma 8] It is easy to see that the values computed by procedures computeSpare and computeLow cannot simultaneously satisfy the thresholds of Fact 2, i.e., simplifiedInfl and simplifiedDefl are never called in the same step.Let t 1 , t 2 , . . .be the set of steps where, for every i 1, a node calls either Procedure simplifiedInfl or Procedure simplifiedDefl in t i .Fixing a constant δ such that δ 1/4ζ, we need to show that t i+1 − t i δn.
We distinguish several cases: The following corollary summarizes the bounds that we get when using the simplified type-2 recovery:6 Corollary 1 Consider the (simplified) variant of DEX that uses Procedures A.5 and A.6 to handle type-2 recovery.With high probability, the amortized running time of any step is O(log n) rounds, the amortized message complexity of any recovery step is O(log 2 n), while the amortized number of topology changes is O(1).

Worst Case Bounds for Type-2 Recovery
Whereas Lemma 3 shows O(log n) worst case bounds for steps with type-1 recovery, handling of type-2 recovery that we have described so far yields amortized polylogarithmic performance guarantees on messages and rounds w.h.p. per step (cf.Cor. 1).We now present a more complex algorithm for type-2 recovery that yields worst case logarithmic bounds on messages and rounds per step (w.h.p.).The main idea of Procedures inflate and deflate is to spread the type-2 recovery over Θ(n) steps of type-1 recovery, while still retaining constant node degrees and spectral expansion in every step.
The coordinator The node w that currently simulates the virtual vertex with integer-label 0 ∈ V (Z t−1 (p i )) = Z p i is called coordinator and keeps track of the current network size n and the sizes of LOW and SPARE as follows: Recall that we start out with an initial network of constant size, thus initially coordinator w can compute these values with constant overhead.If an insertion or deletion of some neighbor of v occurs and the algorithm performs type-1 recovery, then v informs coordinator w of the changes to the network size and the sizes of SPARE and LOW (by routing a message along a shortest path in Z t−1 (p i )) at the end of the type-1 recovery.Node v itself simulates some vertex x ∈ Z p i and hence can locally compute a shortest path from x to 0 (simulated at w) according to the edges in Z t (p i ) (cf.Fact 1).The neighbors of w replicate w's state and update their copy in every step.If the coordinator w itself is deleted, the neighbors transfer its state to the new coordinator that subsequently simulates 0. The coordinator state requires only O(log n) bits and thus can be sent in 1 message.Keep in mind that the coordinator does not keep track of the actual network topology or SPARE and LOW, as this would require Ω(n) rounds for transferring the state to a new coordinator.

Staggering the Inflation
We proceed in 2 phases each of which is staggered over θn steps.Let P C denote the p-cycle at the beginning of the inflation step.If, in some step t 0 the coordinator is notified (or notices itself) that |SPARE| < 3θn, it initiates (staggered) inflation to build the new p-cycle P C on Z p i+1 by sending a request to the set of nodes I that simulate the set of vertices S = {1, . . ., 1/θ }.The 1/θ nodes in I are called active in step t 0 .
Phase 1: Adding a larger p-cycle For every x ∈ S, the simulating node in I adds a cloud of vertices as described in Phase 1 of simplifiedInfl.More specifically, for vertex x we add a set Y ⊂ V (P C ) of c(x) vertices, as defined in Eq. ( 7) on page 11.We denote this set of new vertices by NEWSIM(v).That is, node v now simulates |LOAD(v)| + |NEWSIM(v)| many vertices.In contrast to simplifiedInfl, however, vertex x ∈ P C and its edges are not replaced by Y (yet).For each node in y ∈ Y , the simulating node v computes the cycle edges and inverse y −1 ∈ P C .It is possible that y −1 is not among the vertices in S, and hence is not yet simulated at any node in I. Nevertheless, by Eq. ( 7), v can locally compute the vertex x ∈ P C that is going to be inflated to the cloud that contains y −1 ∈ P C .Therefore, we add an intermediate edge (y, x ), which requires O(log n) messages and rounds.Note that |NEWSIM(v)| could be as large as 4ζ 2 .Therefore, similarly as in Phase 2 of simplifiedInfl, a node in I needs to redistribute newly generated vertices if |NEWSIM| > 4ζ as follows: The nodes in I proceed by performing random walks to find node with small enough NEWSIM.Note that, even though inflate has not yet been processed at nodes in V (G t ) \ I, any node that is hit by this random walk can locally compute its set NEWSIM and thus check if it is able to simulate an additional vertex in the next p-cycle P C .Since we have O(1) nodes in I each having O(1) vertices in their NEWSIM set, these walks can be done sequentially, i.e., only 1 walk is in progress at any time, which takes O(log n) rounds in total.After these walks are complete and all nodes in I have |NEWSIM| 4ζ, the coordinator is notified and forwards the inflation request to nodes I that simulate vertices S = { 1/θ + 1, . . ., 2 1/θ }. (Again, this is done by locally computing the shortest path in P C.) In step t 0 + 1, the nodes in I become active and proceed the same way as nodes in I in step t 0 , i.e., clouds and intermediate edges are added for every vertex in S .
Phase 2: Discarding the old p-cycle.Once Phase 1 is complete, i.e., all nodes are simulating the vertices in their respective NEWSIM set, the coordinator sends another request to the set of nodes I -the active nodes in the next step-that are still simulating the set S of the first 1/θ vertices in the old p-cycle P C.
Every node in I drops all edges of P C and stops simulating vertices in V (P C).In the next step, this request is forwarded to the nodes that simulate the next θn vertices and reaches all nodes within θn steps.After T = 2θn steps7 , the inflation has been processed at all nodes.
Finally, we need to argue that type-1 recovery succeeds with high probability while the staggered inflation is ongoing: If the adversary inserts a node w in any of these T steps, we can simply assign one of the newly inflated vertices to w. If, on the other hand, the adversary deletes nodes, we need to show that, for any t ∈ [t 0 , t 0 + T ], it holds that |LOW t | θn.Recalling that the coordinator invoked the inflation in step t 0 because |SPARE t 0 | < 3θn, it follows that |LOW t 0 | n − 3θn.In the worst case, the adversary deletes 1 node in every one of the following T steps, which increases the load of at most 2θn nodes.This yields that |LOW t | |LOW t 0 | − 2θn = n − 5θn θn, due to (3).Thus, since the assumption of Lemma 2.(b) holds throughout steps [t 0 , t 0 + T ], type-1 recovery succeeds with high probability as required.

Staggering the Deflation
We now describe the implementation of deflate that yields a worst case bound of O(log n) for the recovery in every step.Similarly to inflate, the coordinator initiates a staggered deflation whenever the threshold |LOW| < 3θ is reached and the algorithm proceeds in two phases: Phase 1: Adding a smaller p-cycle Phase 1 is initiated during the recovery in some step t 0 by the (current) coordinator w who sends a message to nodes S that simulate vertices I = {1, . . ., 1/θ }.The nodes in S become active in the recovery of step t 0 and will start simulating the (smaller) p-cycle Z(p s ) in addition to the current p-cycle Z t 0 (p i ) by the end of the step, as described below.As in the case of inflate, w can efficiently find S (requiring only O(log n) messages and rounds) by following the shortest path in the current p-cycle Z t 0 (p i ).Let α = p i /p s and consider some node v ∈ S. For every x ∈ SIM(v), node v computes y x = x/α and starts simulating y x ∈ Z(p s ), if there is no x < x such that x = x /α .That is, the new vertices are determined exactly the same way as in Phase 1 of simplifiedDefl and node v adds y x to NEWSIM(v).
Assuming that there is a y x ∈ NEWSIM(v), node v marks all x 1 , . . ., x k ∈ Z t 0 (p i ) that satisfy y x = x j /α , for 1 j k, as taken.We say that x dominates x 1 , . . ., x k and we call the set {x 1 , . . ., x k } a deflation cloud.Note that some of the vertices of a deflation cloud might be simulated at other nodes.Nevertheless, according to the edges of Z t 0 (p i ), these nodes are in an O(1) neighborhood of v and can thus be notified to mark the corresponding vertices as taken.Intuitively speaking, if a node v simulates such a dominating vertex x, then v is guaranteed to simulate a vertex in the new p-cycle Z(p s ), and the surjective requirement of the virtual mapping is satisfied at v. Thus our goal is to ensure that every node in S simulates a dominating vertex by the end of the recovery of this step.
The problematic case is when none of the vertices currently simulated at node v dominates for some y x ∈ Z(p s ).To ensure that v simulates at least 1 vertex of the new p-cycle Z(p s ), node v initiates a random walk on the graph Z(p s ) to find a dominating vertex that has not been marked taken.We thus lower-bound the size of dominating vertices that are never marked as taken, in any of the θn steps during which deflate is in progress: Recall that the coordinator invoked deflate because |LOW| < 3θ.This means that (1 − 3θ)n nodes have LOAD t 0 > 2ζ and the total load in the network is at least (2ζ(1 − 3θ) + 3θ)n since every node simulates at least 1 vertex.If some node simulates a dominating vertex x, then all of the (at most α 8) dominated vertices x > x that also satisfy y x = x /α are marked as taken.Considering that ζ 8, the number of dominating vertices is at least (2ζ(1 − 3θ) + 3θ)n/8 (2 − θ(6 + 3/ζ))n.In each of the θn steps while Phase 1 of deflate is in progress, the adversary might insert some node that starts simulating a dominating vertex.Thus, in total we must give up n + θn dominating vertices.It follows that the number of dominating vertices that are available (i.e.not needed by any node) is at least Recalling (3) on page 9, the right hand size is at least a constant fraction of n, i.e., the set of available dominating vertices D has size εn while deflate is in progress, for some ε > 0. Similarly to the proof of Lemma 2, we can use the concentration bound of [9] to show that a random walk of v of length O(log n) hits a vertex in D with high probability.To avoid clashes between nodes in S, we perform these walks sequentially.Since there are only O(1) nodes in S, this takes overall O(log n) time and messages.
In step t 0 + 1, the nodes that simulate the next 1/θ vertices become active and so forth, until the request returns to the (current) coordinator after θn steps.
Phase 2: Discarding the old p-cycle Once the new (smaller) p-cycle Z(p s ) has been fully constructed, the coordinator sends another request to the nodes in I-which again become active nodes-that simulate the 1/θ vertices in S. Every node in I drops all edges of E(Z(p i )) and stops simulating vertices in V (Z(p i )).This request is again forwarded to the nodes that simulate the next θn vertices and finally has reached all nodes within θn steps.Thus, after T = 2θn steps, the deflation has been completed at all nodes.
Since the coordinator initiated the deflation because |LOW t 0 | < 3θn, it follows that |SPARE t 0 | n − 3θn, and thus |SPARE t | θn, for all steps t ∈ [t 0 , t 0 + T ].Therefore, by an argument similar to Procedure inflate, it follows that type-1 recovery succeeds w.h.p. until the new virtual graph is in place.
Lemma 9 (Worst Case Bounds Type-2 Recovery) Suppose that the coordinator initiates either inflate of deflate during recovery in some step t 0 and G t 0 −1 is 4ζ-balanced.Then, for all steps t ∈ [t 0 , t 0 + T ] where T = 2θn the following hold: (a) Every node simulates at most 8ζ vertices and the recovery in t requires at most O(log n) rounds and messages (w.h.p.), while making only O(1) changes to the topology.(b) The spectral gap of G t is at least (1−λ) 2 8 where 1−λ is the spectral gap of the p-cycle expander family.
Proof.First consider (a): The bound of 8ζ vertices follows from the fact that, during inflate and deflate, any node simulates at most 4ζ vertices from both p-cycles.This immediately implies a constant node degree.Recalling the description of Phases 1 and 2 for inflate and deflate, we observe that either phase causes an overhead of O(log n) messages and rounds for each of the O(1) active nodes during recovery in some step t ∈ [t 0 , t 0 + T ]; the worst case bounds of (a) follow.
We now argue that, at any time during the staggered inflation, we still guarantee a constant spectral gap.By the left inequality of Theorem 2 (App.A), a spectral expansion of λ G t 0 −1 yields an edge expansion (cf.Def. 5 in App. . For both, inflate and deflate, it holds that during Phase 1, nodes still simulate the full set of vertices and edges of the old p-cycle and some intermediate edges of the new p-cycle.In Phase 2, on the other hand, nodes simulate a full set of vertices and edges of the new p-cycle and some edges of the old p-cycle.Thus, during either phase, the edge expansion is bounded from below by the edge expansion of the p-cycle expander family.That is, we have h(G t ) h(G t 0 −1 ), for any step t ∈ [t 0 , t 0 + T ].It is possible, however, that the additional intermediate edges decrease the spectral expansion.Nevertheless, we can apply the right inequality of Theorem 2 to get

Implementing a Distributed Hash Table (DHT)
We can leverage our expander maintenance algorithm to implement a DHT as follows: Recall that the current size s of the p-cycle is global knowledge.Thus every node uses the same hash function h s , which uniformly maps keys to the vertex set of the p-cycle.
We first look at the case where no staggered inflation/deflation is in progress: If some node u wants to store a key value pair (k, val) in the DHT, u computes the index z := h s (k).Recall that u can locally compute a shortest path z 1 , z 2 , . . ., z (in the p-cycle) starting at one of its simulated virtual vertices z 1 and ending at vertex z.Even though node u does not know how this entire path is mapped to the actual network, it can locally route by simply forwarding (k, val) to the neighboring node v 2 that simulates z 2 ; node v 1 in turn forwards the key value pair to the node that simulates z 3 and so forth.The node that simulates vertex z stores the entry (k, val).If z is transferred to some other node w at some point, then storing (k, val) becomes the responsibility of w.Similarly, for finding the value associated with a given key k , node u routes a message to the node simulating vertex h s (k ), who returns the associated value to u.It is easy to see that insertion and lookup both take O(log n) time and O(log n) messages and that the load at each node is balanced.
We now consider the case where a staggered inflation (cf.Procedure A.8) has been started and some set of nodes have already constructed the next larger p-cycle of size s .Let P C be the old (but not yet discarded) p-cycle and let P C denote the new p-cycle that is currently under construction.For a given vertex z i ∈ P C we use the notation z i to identify the unique vertex in P C that has the same integer label as z i .
Note that all nodes have knowledge of the hash function h s , which maps to the vertices of P C .Suppose that a node u ∈ S becomes active during Phase 1 of the staggered inflation and starts simulating vertices z 1 , . . ., z ∈ P C .(For clarity of presentation, we assume that 4ζ, thus u does not need to redistribute these vertices.The case where > 4ζ can be handled by splitting the operations described below among the nodes that end up simulating z 1 , . . ., z .)At this point, some set S of j nodes might still be simulating the corresponding vertices z 1 , . . ., z ∈ P C, where j ∈ O(1).Thus node u contacts the nodes in S (by routing a message to vertices z 1 , . . ., z along the edges of P C) and causes these nodes to transfer all data items associated with z 1 , . . ., z to u.From this point on until the staggered inflation is complete, the nodes in S forward all insertion and lookup requests regarding z 1 , . . ., z to node u.Note that the above operations require at most O(log n) rounds and messages, and thus only increase the complexity of the staggered inflation by a constant factor.
The case where a staggered deflation is in progress is handled similarly, by transferring key value pairs of vertices that are contracted to a single vertex in the new (smaller) p-cycle, whenever the simulating node becomes active.at all times.There are some open questions: Is an O(log n) overhead sufficient for handling even a linear number of insertion/deletions per step?How can we deal with malicious nodes in this setting?
Proof.The result follows by instantiating Lemma 2.2 of [7], which shows that, if every node initiates η random walks of length µ, then all walks complete within O( ηµ log n δ ) rounds where δ is the minimum node degree.
Corollary 2 (Corollary 7.7.3 in [28]) In any bounded degree expander of n nodes, n packets, one per node, can be routed according to an arbitrary permutation in O log n(log log n) 2 log log log n rounds.Our framework can be extended to a model where the adversary can insert or delete multiple nodes in each step, with certain assumptions: Insertions: The adversary can insert or delete a set N of up to εn many nodes in each step, for some small ε > 0. We restrict the adversary to attach only a constant number of nodes in N to any node-dropping this restriction will allow the adversary to place the whole set N at the same node u, causing significant Given: DIAM is the diameter of Z t (i.e.DIAM ∈ O(log n)).1: Node u broadcasts an aggregation request to all its neighbors.In addition to the network size, this request indicates whether to compute |LOW| or |SPARE|.That is, the request of u traverses the network in a BFS-like manner and then returns the aggregated values to u. 2: If a node w receives this request from some neighbor, it computes the aggregated maximum value, according to whether w ∈ SPARE for computeSpare (resp.w ∈ LOW for computeLow).3: If node w has received the request for the first time, w forwards it to all neighbors (except v).4: Once the entire network has been explored this way, i.e., the request has been forwarded for DIAM rounds, the aggregated maximum values of the network size and |LOW| (resp.|SPARE|) are sent back to u, which receives them after 2DIAM rounds.
within a constant number of insertion steps.Nevertheless we can still handle such large-scale insertions via type-2 recovery by using Procedure simplifiedInfl.Deletions: For deletions, we only allow the adversary to delete nodes that leave the remainder graph connected, i.e., if the adversary removes nodes N at time t, G t−1 \ N is still connected.Moreover, for each deleted node there must remain at least one neighbor in the set G t−1 \ N .As in the case of insertions, such large-scale deletions might require Procedure simplifiedDefl to be invoked every constant number of steps.
Corollary 3 (Multiple Insertions/Deletions) Suppose that the adversary can insert or delete εn nodes, for some small ε > 0 in every step adhering to the following conditions: In case of insertions, the adversary attaches O(1) nodes to any existing node in the network.In case of deletions, the remaining graph is connected and, for each deleted node u, some neighbor of u is not deleted.There exists a distributed algorithm that requires O(n log 2 n) messages and O(log 3 n) rounds (w.h.p.) for recovery in every step.
1: Assumption: Let w be the coordinator node that maintains local counters of SPARE, LOW and the network size (cf.Algorithm A.7).Moreover, the coordinator has computed the prime number p i+1 of the larger p-cycle to which we inflate.
Phase 1. Adding a larger p-cycle: 2: The coordinator sends an initiation request to the nodes I that simulate the vertices S = {1, . . ., 1/θ}.This set I are the active nodes in the recovery of the current step.
(Compute the new set of locally simulated virtual vertices.)Every node u ∈ I does the following: Let α = p i+1 p i and define the function c(x) = α(x + 1) − αx − 1. 3: For every x ∈ SIM(u) (i.e.x ∈ Z t−1 (p i )), node u adds a cloud of virtual vertices y 0 , . . ., y c(x) where y k = ( αx + k) mod p i+1 , for 0 k c(x).That is, CLOUD(y 0 ) = • • • = CLOUD(y c(x) ) = {y 0 , . . ., y c(x) }. 4: Node u adds all such generated vertices y i to the set NEWLOAD(u). 5: for every x ∈ SIM(u) and every y k , (0 k c(x)) do (Compute the new set of edges.)Cycle edges: Add an edge between u and the nodes v and v that simulate y k − 1 and y k + 1 by using the cycle edges of Z t−1 (p i ) in G t .In case that v (or v ) have not yet been active in Phase 1, we place an intermediate edge from u to v, resp.v .Inverse edges: Add an edge between u and the node that is going to simulate y −1 k .Node u can locally compute the vertex x (simulated at some node v ), for which the corresponding cloud (containing y −1 k ) is going to be added, and hence can add an intermediate edge to the node v .The communication from u to v can be established along a shortest path (in Z t−1 ).This shortest path can be computed locally, since every node knows the complete virtual graph.6: After all additional vertices have been generated, the nodes in I, start initiating random walks of length O(log n) to distribute any (new) vertices that exceed the treshold of NEWLOAD > 4ζ.These walks are performed sequentially in some arbitrary order.(Note that |I| ∈ O(1).) 7: Once these walks are complete, the coordinator is informed and contacts the nodes I that simulate the next 1/θ vertices of the current virtual graph.When the adversary triggers the next step, these nodes in turn locally generate their portion of Z(p i+1 ) and so forth.After θn steps, Phase 1 is complete at all nodes.
Phase 2. Discard the old p-cycle: 8: The coordinator sends another request to the set of nodes I that host the first 1/θ vertices in S. 9: This causes every node in I to drop all edges of Z(p i ) and stop simulating the corresponding vertices.10: In the recovery of the next step, the coordinator forwards this request to the next 1 /θ nodes and so forth.After θn steps, Phase 2 is complete and all nodes now (exclusively) simulate the new virtual graph Z(p i+1 ).
Algorithm A.8: Procedure inflate 1: Assumption: Let w be the coordinator node that maintains local counters of SPARE, LOW and the network size (cf.Algorithm A.7).Moreover, the coordinator has computed the prime number p s of the smaller p-cycle to which we deflate.
Phase 1. Compute smaller p-cycle: Every node u ∈ I does the following: 2: (Compute the new set of locally simulated virtual vertices NEWSIM(u) ⊂ Z(p s ).)Let α = p i ps .For every x ∈ SIM(u) (i.e.x ∈ Z t−1 (p i )) we compute y x = x α .If there is no x < x such that y x = y x , we add y x to NEWSIM(u).This yields the (possibly empty) set NEWSIM(u) = {y x 1 , . . ., y x k }, where x 1 , . . ., x k ∈ Z t−1 (p i ) are a subset of the previously simulated vertices at u.If NEWSIM(u) = ∅, we mark u as contending.For every vertex y x j , we set CLOUD(y x j ) = {m : (m − 1) α y x j < m α }. 3: for every y x j ∈ NEWSIM(u), (1 j k), do (Compute the new set of edges.)Cycle edges: Add an (intermediate) edge between u and the nodes v and v that are going to simulate y x j − 1 and y x j + 1 by using the cycle edges of Z t−1 (p i ) in G t .Inverse edges: Add an(intermediate) edge between u and the node v that is going to simulate y −1 k ; node v is found by communicating along a shortest path in Z(p i ).This shortest path can be computed locally, since every node knows the complete virtual graph.4: After all additional vertices have been generated, the contending nodes in I, start initiating random walks of length O(log n) to find nodes that have NEWLOAD < 4ζ.Note that, even though only nodes in I have generated their part of the new p-cycle, every node can locally compute its value of NEWLOAD upon being hit by such a random walk and hence can generate such vertices on the fly.These walks are performed sequentially in some arbitrary order.(Note that |I| ∈ O(1).) 5: Once these walks are complete, the coordinator is informed and contacts the nodes I that simulate the next 1/θ vertices of the current virtual graph.When the adversary triggers the next step, these nodes in turn will locally generate their portion of Z(p s ) and so forth.After θn steps, Phase 1 is complete at all nodes.
Phase 2. Discard the old p-cycle: 6: The coordinator sends another request to the set of nodes I that host the first 1/θ vertices in S. 7: This causes every node in I to drop all edges of Z(p i ) and stop simulating the corresponding vertices.8: In the recovery of the next step, the coordinator forwards this request to the next 1 /θ nodes and so forth.After θn steps, Phase 2 is complete and all nodes now (exclusively) simulate the new virtual graph Z(p s ).

Figure 2 : A 4 -
Figure2: A 4-balanced virtual mapping of a p-cycle expander to the network graph.On the left is a (virtual) 3-regular 23-cycle expander on Z 23 ; on the right is the network G t with (real) nodes {A, . . ., G}.
the network graph is (Cζ)-balanced, and the maximum clouds size is ζ 8. (b) There is a bijective map between Z p i+1 and V (Z t (p i+1 )).(c) The edges of Z t (p i+1 ) adhere to Definition 1.

Lemma 5 (
Simplified Type-2 recovery) Suppose that G t−1 is 4ζ-balanced and type-2 recovery is performed in t via simplifiedInfl or simplifiedDefl.The following holds: (a) G t is 4ζ-balanced.(b) With high probability, step t completes in O(log 3 n).(c) With high probability, nodes send O(n log 2 n) messages.(d) The number of topology changes is O(n).

Claim 1
Consider a fixed constant c.If |Balls i | c log n, then epoch i takes O(log 2 n) rounds, w.h.p.Otherwise, if |Balls j | < c log n, then j comprises O(log 3 n) rounds w.h.p.

1 Lemmas 3
and 9 imply the sought worst case bounds of Theorem 1.The constant node degree follows from Lemma 3.(a) and Lemma 9.(a).Moreover, Lemma 9.(b) shows a constant spectral gap for (the improved) type-2 recovery steps and the analogous result for type-1 recovery follows from Lemma 1 and Lemma 3.(a).

Lemma 12 (
Mixing Lemma, cf.Lemma 2.5[14]) Let G be a d-regular graph of n vertices and spectral gap 1 − λ.Then, for all set of nodes S, T ⊆ V (G), we have that |E(S, T )| − d|S||T | n λd |S||T |.Definition 5 (Edge Expansion, [14]) Consider a graph G of n nodes and a set S ⊆ V (G).Let E(S, S) be the set of edges between S and G \ S. The edge expansion of G is defined as h(G) := min |E(S, S)| |S| : S ⊆ V (G) and |S| n/2 .
Lemma 3 (Worst Case Bounds Type-1 Rec.)If type-1 recovery is performed in t and G t−1 is 4ζ-balanced, t is 4ζ-balanced, (b) step t takes O(log n) (w.h.p.), rounds, (c) nodes send O(log n) messages in step t (w.h.p.), and (d) the number of topology changes in t is constant.
4.4) to give O(log n) worst case bounds.Recall that we perform type-1 recovery in step t, as long as θn nodes are in SPARE G t−1 when a node is inserted, resp. in LOW G t−1 , upon a deletion.If the algorithm performs type-2 recovery in t, the following holds: (a) If a node is inserted in t, then |SPARE G t−1 | < θn.(b) If a node is deleted in t, then |LOW G t−1 | < θn.4.2.1 Inflating the Virtual Graph If node v fails to find a spare node for a newly inserted neighbor and computes that |SPARE G t−1 | < θn, i.e., only few nodes simulate multiple virtual vertices each, it invokes Procedure simplifiedInfl (cf. Algorithm A.5for the detailed pseudo code), which consists of two phases:Phase 1: Constructing a Larger p-Cycle Node v initiates replacing the current p-cycle Z t−1 (p i ) with the larger p-cycle Z t (p i+1 ), for some prime number p i+1 ∈ (4p i , 8p i ).This rebuilding request is forwarded throughout the entire network to ensure that after this step, every node uses the exact same new p-cycle Z t .Intuitively speaking, each virtual vertex of Z t−1 is replaced by a cloud of (at most ζ 8) virtual vertices of Z t and all edges are updated such that G t is a virtual mapping of Z t .
then Phase 1 of simplifiedDefl ensures that every node computes the same virtual graph Z t (p s ) in O(log n(log log n) 2 ) rounds such that (a) p s = |Z t (p s )| ∈ (p i /8, p i /4), for some prime p s ; (b) there is a one-to-one mapping between Z ps and V (Z t (p s )); (c) the edges of Z t (p s ) adhere to Definition 1.
Proof.[of Claim 2] First, consider the set of nodes S = U t \ SPARE Ut , i.e., LOAD Ut (u) = 1 for all u ∈ S. By Fact 2.(a), we have |S| (1 − θ)n.Clearly, any such node u ∈ S simulates at most ζ virtual vertices after generating its own vertices for the new virtual graph, hence the only way for u to reach LOAD t (u) > 2ζ is by taking over vertices generated by other nodes.By the description of procedure simplifiedInfl, only (a subset of) the nodes in SPARE Ut redistribute their load by performing random walks.By Lemma 7, we can assume that G t 1 −1 is 4ζ-balanced.Since |SPARE Ut | < θn, we have a total of (4ζ − 4)θn clouds that need to be redistributed.Observe that v continues to simulate 4 clouds (i.e.4ζ nodes) by itself.Since every node that is in S, has at most ζ virtual nodes, we can bound the size of LOW t by subtracting the redistributed clouds from |S|.For the result to hold we need to show that(θ + 1/2) 1 − θ − (4ζ − 4)θ,which immediately follows by Inequality (3).Claim 3 Suppose that t is a deflation step.Then |SPARE t | (θ + 1 4ζ )n.Proof.[of Claim 3] Consider the set S = {u : LOAD Ut (u) > 2ζ}.Since S = U t \ LOW Ut , Fact 2.(b) tells us that |S| (1 − θ)n and therefore we have a total load of least (1 − θ)(2ζ + 1)n + θn in U t .By description of procedure simplifiedDefl, every cloud of virtual vertices is contracted to a single virtual vertex.After deflating we are left with 1. t i simplifiedInfl; t i+1 simplifiedInfl: By Fact 2.(a) we know that SPARE Ut i contains less than θn nodes.Since we inflate in t i , every node generates a new cloud of virtual vertices, i.e., the load of every node in U t i is (temporarily) at least ζ (cf.Phase 1 of simplifiedInfl).Moreover, the only way that the load of a node u can be reduced in t i , is by transferring some virtual vertices from u to a newly inserted node w.However, by the description of simplifiedInfl and the assumption that ζ > 2, we still have LOAD t (u) > 1 (and LOAD t (w) 1), and therefore SPARE Gt i ⊇ V (G t i ) \ {w}.Since the virtual graph (and hence the total load) remains the same during the interval (t i , t i+1 ), it follows by Lemma 7 that SPARE can shrink by at most the number of insertions during (t i , t i+1 ).Since |SPARE Ut i+1 | < θn, more than (1 − θ)n − 1 > δn insertions are necessary.2. t i simplifiedDefl; t i+1 simplifiedDefl: We first give a lower bound on the size of LOW Gt i .By Lemma 5, we know that load at every node is at most 4ζ in U t i .Since every virtual cloud (of size ζ) is contracted to a single virtual zertex in the new virtual graph, the load at every node is reduced to at most 4. Clearly, the nodes that are redistributed do not increase the load of any node beyond 4, thus LOW t = G t .Analogously to Case 1, the virtual graph is not changed until t i+1 and Lemma 7 tells us that LOW is only affected by deletions, i.e., (1 − θ)n δn steps are necessary before step t i+1 .3. t i simplifiedInfl; t i+1 simplifiedDefl: By Claim 2, we have |LOW Gt i | (θ + 1/2)n, while Fact 2.(b) tells us that |LOW Gt i+1 | < θn.Again, Lemma 7 implies that the adversary must delete at least n/2 δn nodes during (t i , t i+1 ].By Claim 3, we have |SPARE Gt i | (θ + 1 4ζ )n, and by Fact 2.(a), we know that |SPARE Gt i+1 | < θn.Applying Lemma 7 shows that we must have more than 1 4ζ n δn deletions before t i+1 .
Case 1: Adversary inserts a node u: Try to find a spare vertex for u via a random walk (type-1 recovery).iftype-1 recovery fails then if most nodes simulate only 1 vertex then Perform type-2 recovery by inflating.elseRetry type-1 recovery until it succeeds.Case 2: Adversary deletes a node u: Try distributing vertices that were simulated at u via random walks (type-1 recovery).