In this work, we study efficient distributed algorithms for assignment problems. The task is to assign each customer to one adjacent server, and the customers prefer servers with a low load, i.e., few other customers. We are interested in finding a stable assignment, that is, an assignment in which no customer has incentive to unilaterally switch servers. The stable assignment problem that we study here is also known as a locally optimal semi-matching, and it was studied in the distributed setting by Czygrinow et al. [CHSW12].
We will start by studying a restricted version of the problem, stable orientation, which is the special case in which all customers can choose between two possible servers, and we will then see how the same ideas generalize also to the stable assignment problem.
We approach these problems by introducing a new graph problem called the token dropping game. We show how to solve the token dropping game efficiently in the distributed setting, and how one can employ an efficient solution to the token dropping game to solve the stable orientation and stable assignment problems efficiently. Furthermore, we prove lower bounds for the token dropping game as well as to the stable assignment problem.
The main technical contribution is that we improve the distributed round complexity of stable orientations from to , and also prove a lower bound of for graphs of maximum degree , both of these in the standard LOCAL [Lin92, Pel00] model of distributed computing.
1.1 Stable orientations
Consider the following game on a graph:
More precisely, we say that an oriented edge is happy if
that is, turning the orientation of from to would not lower the indegree of the head of edge . An orientation is stable if all edges are happy. See Figure 1 for examples.
Customers and servers.
We can interpret each edge as a customer and each node as a server. If an edge is oriented from to , then customer is using server . The load of a server is the total number of customers using it, i.e., its indegree. Customers would like to use servers with a low load, in order to maximize the quality of service they receive.
Centralized sequential algorithms.
There is a simple centralized sequential algorithm that finds a stable orientation: start with an arbitrary orientation and then repeatedly pick an arbitrary unhappy edge and flip it. Flipping one edge may create new unhappy edges. However, it is easy to see that the algorithm will terminate in polynomial time in the number of nodes: the sum of squared indegrees is strictly decreasing.
This also shows that a stable configuration serves simultaneously two purposes: it is a game-theoretic equilibrium, and it is also a local optimum in a load-balancing problem in which the goal is to minimize the sum of squared loads.
Efficient distributed algorithms.
The centralized algorithm is inherently sequential, and it may lead into a long propagation chain: flipping one unhappy edge creates another unhappy edge, flipping that one creates yet another, and such changes may eventually propagate throughout the graph.
Surprisingly, we can do much better in a distributed setting: [CHSW12] gave a distributed algorithm that finds a stable orientation in communication rounds, where is the maximum degree of the graph. Remarkably, the running time is independent of the size of the graph, and only depends on . Even if we have an infinite graph, as long as the maximum degree is bounded, the nodes can collectively find some stable configuration in finite time.
However, hardly sounds like a natural barrier for such a simple problem, but so far no improved algorithms or nontrivial lower bounds are known. In this work we present both.
1.2 Token dropping game
The key new idea that we use to solve the orientation game is to introduce a new graph problem that we call the token dropping game. The game is illustrated in Figure 2. The input consists of a graph in which the nodes are organized in layers, numbered from to . Some of the nodes hold a token; a node can hold at most one token. The rules are simple:
Put otherwise, once an edge has been used to move a token, it is deleted. Task is to find some possible sequence of token movements such that we reach a configuration in which no token can be moved any more. I.e., the only goal of this single player game is to get stuck.
Centralized sequential algorithms.
Again, there is a trivial centralized sequential algorithm for solving the token dropping problem: repeatedly pick any token that can be moved downwards and move it by one step. Eventually no token can be moved and the game is solved.
Efficient distributed algorithms.
In this work we show that the token dropping problem can be solved in rounds with a distributed algorithm; we also prove a lower bound of rounds.
Using token dropping to find stable orientations.
We show that any algorithm that solves token dropping in rounds can be used to find a stable orientation in rounds. Plugging in our algorithm for token dropping, we obtain an algorithm for finding a stable orientation in rounds, a factor- improvement over the previous algorithm by [CHSW12]. We also prove a lower bound of for any algorithm that finds a stable orientation.
On a high level, the key new idea that enables us to save time in comparison with the prior algorithm is the following:
In the prior work, one starts with an arbitrary orientation. This potentially creates a large amount of unhappiness and resolving it takes a lot of time.
In our work we orient edges more carefully, so that there is always at most one unit of excess load per node. We play token dropping with the excess load in order to resolve unhappiness. After such iterations, all edges are happily oriented.
1.3 Generalization: stable assignment and semi-matchings
Let us define a generalization of stable orientations as follows: Consider a bipartite graph in which we have customers on one side and servers on the other side. The task is to assign each customer to one server. Again, the customers would like to selfishly minimize the load of the server to which they are assigned to. We call a solution in which no customer wants to change its assigned server a stable assignment.
Note that the stable orientation problem is the special case of stable assignment with degree- customers only. The prior algorithm by [CHSW12] also solves the more general stable assignment problem. While our focus is on the orientation problem, we will also explain in this work how to generalize our algorithm beyond degree- customers. If the maximum degree of a customer is and the maximum degree of a server is , our algorithm runs in rounds and the algorithm from prior work runs in rounds. For the balanced case , both of the algorithms run in rounds.
The stable assignment problem is closely connected to a load balancing problem known as semi-matching [HLLT06]. There the task is to assign each customer to one server while minimizing the objective function , where is the number of customers assigned to server and . In essence, this is almost the same problem as minimizing the sum of squared loads. As observed by [CHSW12], a stable assignment is also a factor- approximation of the optimal semi-matching. Hence our work gives also a faster -approximation algorithm for semi-matchings in the case of low-degree customers and high-degree servers.
Open question for future work.
A stable assignment can be used to find a -approximation of semi-matching. However, any algorithm that finds a stable assignment takes at least rounds. Is it possible to find a -approximation of semi-matching in time by some other means (without going through a stable assignment)?
1.4 Relaxation: 0–1–many assignments
We conjecture that finding a stable orientation requires at least rounds, i.e., it is strictly harder than e.g. the problem of finding a maximal matching in a bipartite graph, which is solvable in rounds. If this is indeed the case, stable orientations would be a rare example of a natural graph problem that is solvable in but not in rounds (see Section 2 for more discussion on related work).
We are currently still far from being able to prove superlinear lower bounds for stable orientations with the present techniques, but in this work we will provide evidence suggesting that at least the general stable orientation problem is unlikely to be solvable in rounds.
To do this, we consider the following highly relaxed version of stable orientations: each customer is assigned to one adjacent server, and a customer does not want to use a server of load at least if there is a server of load available. In essence, this is a ––many version of stable orientations: customers only care about the difference between servers of load , load , and load at least . We prove the following:
The ––many version requires rounds.
The ––many version can be solved in rounds.
Hence the best upper bound for the relaxed version is much lower than for the general stable assignment problem, which is solvable in rounds. This suggests that the relaxed version is indeed strictly easier than the general version. If one could prove a strict separation between the relaxed version and the general version, then our lower bound for the relaxed version would imply an lower bound for the general version, providing one of the first examples of a natural graph problem with a superlinear-in- complexity.
Open question for future work.
Can we show that the ––many version of stable assignments is strictly easier than the general version? For example, if we have an algorithm that solves the general version in graphs of maximum degree in some time , can we use it to solve the ––many version in graphs of maximum degree , in the same time ?
1.5 Organization of the paper
Our paper is organized as follows. We start by discussing additional related work in Section 2 and formalize the model of computing in Section 3. In Section 4, we introduce the token dropping game and give an upper and a lower bound for its complexity. In Section 5, we show how to use the token dropping to find stable orientation in rounds and in Section 6, we give a lower bound. Then, in Section 7, we show to generalize our techniques to the stable assignment problem and discuss the complexity of the --many relaxation of the stable assignment problem.
2 Related work
Distributed complexity of locally verifiable problems.
This work is part of the ongoing effort of understanding the distributed computational complexity of locally verifiable problems. In brief, these are problems in which a solution is globally correct if it looks good in all constant-radius neighborhoods. Stable orientations are by definition locally verifiable: if all edges are happy, the orientation is stable, and the happiness of an edge only depends on the other edges adjacent to it.
The study of locally verifiable problems in distributed computing plays a role similar to the study of the class NP in classical centralized sequential computing: given a problem in which solutions are easy to verify, what can we say about the complexity of finding a feasible solution?
Typically, the complexity of locally verifiable problems is studied as a function of two parameters, the number of nodes and the maximum degree . In essence, these capture two complementary notions of scalability: how does the complexity of finding a solution increase when the input graph gets larger vs. when the input graph gets denser.
In general, the landscape of the distributed computational complexity for each possible combination of and is complicated, but there are many problems that provide an opportunity to focus on one parameter only. To study the distributed complexity as a function of , we can simply set and hence focus on bounded-degree graphs. In this case there are two important families of locally verifiable problems:
Orientation and splitting problems, such as sinkless orientation, sinkless and sourceless orientation, almost-balanced orientation, and almost-balanced splitting: all of these problems can be solved in with randomized algorithms and in rounds with deterministic algorithms [GS17, GHK17], and these are tight [BFH16, CKP16].
The other dimension, dependency on , requires more care, as one cannot merely set and study asymptotics as a function of . Therefore it is helpful to identify natural examples of graph problems that can be solved in rounds for some function , independently of . In essence, we can set and study the complexity as a function of . Key examples of problems that can be solved in rounds include these:
All of the above bounds are at most linear in . Stable orientation is perhaps one of the simplest locally verifiable graph problems that is known to be solvable in rounds, but for which the current upper bound is superlinear in . By prior work, we do not have any nontrivial lower bounds for stable orientations, and the best upper bound is . The recent advances in the techniques for proving lower bounds [Bra19, Oli19, BBH19, BFH16] suggest that now would be a good time to revisit the stable orientation problem and see how far we can get in closing the gap between upper and lower bounds. In this work we take the first steps in this direction, by improving the upper bound to and by proving a lower bound of .
Distributed load balancing.
We point out that stable orientations can be interpreted as a distributed load balancing problem. Imagine that there is a load token on each edge; the task is to move each such token to one endpoint so that the load cannot be locally balanced any further.
Now if we let the tokens move freely further away from their original locations, we arrive at the locally optimal load balancing problems, studied in [FHS15]. This is a problem that can be solved in time for some , where is the maximum initial load. However, it is an open question whether the problem can be solved in time . It was conjectured that locally optimal load balancing cannot be solved in rounds, and if this is the case, stable orientations and token dropping are a strictly easier problems than locally optimal load balancing.
The key aspect that makes stable orientations and token dropping easier to solve than load balancing is the restriction that we can only use each edge once. If we “move” one unit of load over an edge by flipping the edge (in stable orientations) or by sliding a token along the edge (in token dropping), the edge cannot be used any more for moving additional load in the same direction. If there is a bottleneck that separates large high-load and low-load regions, an algorithm for load balancing has to essentially move load tokens across such an edge one by one until the load is locally balanced, while an algorithm for stable orientation or token dropping will use the edge only once.
In this work, we consider the standard LOCAL model of distributed computing introduced by [Lin92]: Each node of the input graph is a computational entity and each edge represents a bidirectional communication link. Computation proceeds in synchronous communication rounds and the message sizes are unbounded. The nodes are equipped with unique identifiers and initially, the only information that a node has are the identifiers of its neighbors. Throughout the paper, denotes the number of nodes and denotes the maximum degree of the input graph. We emphasize that even though we discuss directed edges in this work, communication is always allowed in both directions over a communication link.
4 The token dropping game
In this section, we introduce the token dropping game slightly more formally and present our algorithm for solving the game. In the end of the section, we complement this result with a lower bound of communication rounds via a reduction to the maximal matching problem. Interestingly, this lower bound already holds for games with levels.
The input for the token dropping game consists of a directed graph that contains no directed cycles and a set of tokens . The tokens are assigned to the nodes such that each node contains at most one token. Furthermore, each node is assigned a level , where denotes the height of the game. The levels of the nodes and the assignment of the tokens are given by an adversary. The nodes are not aware of any parameters, such as their level, the maximum degree , or the number of nodes in the beginning of the execution.
We say that if there is a directed edge from to , then is a parent of and conversely, is called a child of . If is a parent of , then the level function must satisfy the condition111All of our results work even if we allow that for a parent of . For the sake of the presentation, we chose to restrict the discussions to the case where the edges are between adjacent levels. .
The basic principle is that node can only pass a token to a child and in the end of the execution, is only allowed to possess a token if it cannot pass its token to any of its children. For each token , the goal is to find a path from its original node to its destination , where for every , node is the parent of node . Formally, for each node , the output is a set of pairs of incoming and outgoing edges, where each pair corresponds to a path of a token traveling through.222Note that the traversals of the tokens can be derived from the node-centered output in at most communication rounds. If initially contains a token, then the set is allowed to have one singleton outgoing edge in the set and similarly, if is the destination of a token, there can be one singleton incoming edge. Notice that the token dropping game satisfies the preconditions of a locally checkable problem.
The path for token is referred to as the traversal of . There are three rules
Each edge is used at most once, i.e., the traversals are edge-disjoint. We say that an edge is consumed once it is traversed by a token.
The destination node for each token traversal is unique, i.e., for any two traversals and it holds that .
Each traversal is maximal, i.e., if is the destination node of a traversal , then each incoming edge is either consumed by another traversal or child is the destination of another traversal.
4.1 The proposal algorithm
Now, we present our algorithm for the token dropping game. The algorithm follows a simple proposal strategy, where a token is passed to a child whenever that is possible without causing any conflicts with other tokens that are passed. One of the most important ingredients of our analysis is to identify a way to measure the progress of a token on its traversal. In Lemma 4.4, we show that if a node is making proposals, then many edges are being consumed in its neighborhood. Then, in Lemma 4.5, we show that, for any token , we can find a fixed directed path (see Definition 4.3) of nodes such that, if has not yet reached its destination, at least one node on this path is making progress. Once all edges in the -hop neighborhood of this path are consumed, the token must have reached its destination. The goal of the rest of the section is to provide a proof for the following theorem.
There is an algorithm that solves the token dropping game in rounds, where is the height of the game.
We call a node active if at least one of its parents has a token. Furthermore, we call a node occupied if it contains a token and unoccupied otherwise. Our algorithm works as follows. In every round, every active and unoccupied node requests a token from some parent that has a token, ties broken arbitrarily. If a node receives at least one request, then it passes the token to one (arbitrarily chosen one) of the children it received a request from. Notice that upon passing the token, the edge to the corresponding child is consumed and hence, removed from the game. If a node is occupied and has no children or is unoccupied and has no parents, then terminates. When a node terminates, we also remove it from the game. We note that each round of our algorithm actually consists of two synchronous communication rounds but for the sake of the presentation, we combine two communication rounds into one round for the rest of the discussion.
The output of the proposal algorithm is correct.
It is easy to verify that the traversals are edge-disjoint. Upon traversal an edge is consumed, and hence any edge is traversed by at most one token. For maximality, suppose for a contradiction that there is an unoccupied node that has a parent with a token and edge was not consumed. Since is not consumed and is unoccupied, must have terminated before . However, that is a contradiction since an occupied node does not terminate if it has any children. ∎
Consider the traversal of token given by the proposal algorithm. We define the tail of traversal as the longest path starting in with the property that, for any , node passes at least one token to a child, and the last token passes down goes to node . If did not pass any tokens further down, the tail only contains the node . We refer to the concatenation as the extended traversal of . See Figure 3 for an illustration.
Any node can be active and unoccupied in at most rounds.
Consider a round where is active and unoccupied. By definition of being active, there is at least one parent of that has a token and hence, requests a token from some parent of . The parent will accept exactly one proposal that it receives and hence, its token will be passed on to a child and the corresponding edge will be consumed. In other words, in every round that is active and unoccupied, at least one edge incident to some parent of will be consumed. Since, there are at most parents of that have degree at most each, all of their edges are consumed after rounds in which is active and unoccupied. ∎
Consider an arbitrary token with traversal . At any point in time at which has not reached yet, at least one node is active and unoccupied in the extended traversal of .
Let , for some be the node that holds token at time . Notice that by definition, the first unoccupied node , with along has a parent with a token and hence, is active. Suppose for a contradiction that all nodes on the tail of traversal are occupied. By the definition of a tail, since the node is the last node in the tail, it will never pass its token to any of its children. Therefore, it will never become unoccupied.
Again, by the definition of a tail, node is the last node that node passes a token to. Since is already occupied and will never pass its token, it must be the case that it is already holding the token that passes as its last token. Therefore, will never become unoccupied. By induction, this holds for all the nodes on the tail of , including the destination node of . This contradicts the fact that node is the destination of and hence, yields the lemma. ∎
4.2 A lower bound
To complement our upper bound for the token dropping game, we show a reduction from the maximal matching problem to the token dropping game. A detail that might be of independent interest is that the lower bound already holds for the case of only levels. We were able to design an algorithm for the case of at most levels that matches (the dependency of) this bound but our approach does not seem to generalize beyond levels; the complexity of the token dropping game for or more levels is left as an open question for future work.
There is no deterministic algorithm that solves the token dropping game in rounds in the LOCAL model. This holds even when restricted to games of height .
The proof of the theorem is a simple reduction from the bipartite maximal matching problem to the token dropping game. In a recent work, [BBH19] showed that the bipartite maximal matching problem cannot be solved in rounds in the LOCAL model of distributed computing. Consider a bipartite graph that is an input instance to the maximal matching problem. We create a token dropping instance with levels by considering every node as a level- node with a token and every node as a level- node. The traversals of the output for the token dropping game directly correspond to a maximal matching completing the reduction. ∎
4.3 Token dropping through 3 levels
In this section, we show an algorithm that runs in rounds and solves the token dropping game when the number of levels is bounded by . Our approach, however, does not seem to generalize for a larger number of levels. For the case of levels, the current best algorithm has runtime of (from Theorem 4.1) introducing a gap of factor between the cases of and levels. In the hope of finding better algorithms for an arbitrary number of levels, we believe that it is an interesting first step to solve the case of levels in time .
Our algorithm for 3 levels.
Our approach is a refined version of the proposal algorithm from Section 4.1. In the case of levels, we can leverage the fact the highest and the lowest layers only have level- nodes as neighbors. Inspired by this, the nodes in level take an active role and handle moving the tokens. More precisely, in every round, each active and unoccupied node in level requests a token from a parent that contains a token. Each node in level that gets a request passes its token to one child that made a request. Furthermore, each occupied node in level makes a proposal to an unoccupied child. Then, each node in level that receives a proposal accepts one of the received proposals and thereby the offered token.
Nodes in level terminate as soon as they are unoccupied and get removed from the game. Level nodes terminate if they are occupied or have no more parents left. Finally, nodes in level terminate if they are unoccupied and have no parents or if they are occupied and have no children.
There is a deterministic algorithm that solves the token dropping game of height in rounds in the LOCAL model.
Due to the design of our protocol for levels, it is clear that no node will ever have tokens and all tokens are eventually passed down if there is an unoccupied child. For the runtime analysis, consider some node in layer . Recall that if is occupied and has no children or if is unoccupied and has no parents, then terminates. Hence, we can assume that in every round, node either makes a request to a parent or a proposal to a child. In the case that requests a token from some parent , the parent will accept at least one proposal. In this case, node will pass its token and become unoccupied and since is in level it will terminate. In the case that proposes to some child , this child will accept at least one proposal. Node will receive a token and become unoccupied and since is in level it will terminate. Therefore, in every round, at least one neighbor of will terminate and hence, the runtime bound of communication rounds follows. ∎
5 Finding a stable orientation
In this section, we show how to efficiently find a stable orientation. The key idea is to utilize our algorithm for the token dropping game as a black box to maintain a stable partial solution throughout the execution and to carefully and gradually extend the partial stable solution to a complete stable solution.
There is a deterministic algorithm that finds a stable orientation in communication rounds. This runtime is independent of the size of the input graph.
An overview of our algorithm.
The basic idea behind our algorithm is to start with an unoriented graph and gradually orient the edges until all edges are oriented. We split the execution of our algorithm into phases and our goal is to guarantee that in the end of each phase, there are no unhappy directed edges in the graph. Let be the input graph that is initially unoriented. In the beginning of a phase, each unoriented edge sends a proposal to its endpoint with the smaller load333For the sake of presentation, it is convenient to think of the edge as the actor for sending a proposal. However, this proposal is easy to implement in the node-centered view as well., breaking ties arbitrarily. Each node , that receives a proposal, will accept exactly one of the proposals. When a proposal is accepted by node , we will orient the corresponding edge towards —however, before doing so, we make a preparation step on the graph induced by the already oriented edges in order to avoid creating any unhappy edges due to the new orientations. This preparation step is where we apply the token dropping game as a black box.
Utilizing the token dropping game.
The badness of a directed edge is defined as . An important observation is that as soon as the badness of an edge is strictly larger than , then by flipping the edge, the badness of the edge is reduced and the edge becomes happy. Furthermore, if the badness is at most , then the edge is happy. Let us suppose that every directed edge is happy in the beginning of a phase. Then, we know that the maximum badness for any edge in the graph is at most . We create a token dropping instance by including all directed edges that have badness exactly . All nodes are added into the token dropping instance, even if they end up isolated in the token dropping game. The nodes are assigned to levels according to their current load. In addition, for each unoriented edge selected to be oriented towards node in the current phase, we add a token to node . We note that these unoriented edges are not included in the token dropping instance (in this phase).
Then, we run the token dropping algorithm on the instance we created and obtain a set of traversals. We re-orient all the edges according to the traversals or, in other words, flip every edge present in the traversals. We show in Lemma 5.4 that after flipping the edges, we have badness bounded by and hence, we have our invariant that allows us to proceed to the next phase. In Lemma 5.2 we show that the created token dropping instance is valid and has height bounded by . Finally, in Lemma 5.5, we give a bound on the number of phases we require and are ready to prove Theorem 5.1.
The created token dropping instance is valid and the height of the game is at most .
Since the nodes are assigned to levels according to their loads, the bound for the height of the game follows from the fact that the maximum load of a node is bounded by the maximum degree. Every node can have at most one token since in each phase each node accepts at most one proposal. Finally, all edges have badness exactly one, which implies that they go from a node in layer to some other node in layer . ∎
Consider a node and some phase . The load of increases by in phase if and only if is the destination of a token in the token dropping game created in phase . Otherwise, the load of does not change in phase .
According to the design of our protocol, the orientations of all the edges contained in the traversals are flipped and hence, flipping the edges will not affect the load of nodes that are not the endpoints of a traversal. Consider now the case that is a starting point of a traversal but not an endpoint of any traversal. Flipping the edges decreases the load of by , but directing the undirected edge in the end of the phase cancels out the decrease. If is the endpoint of a traversal, we need to consider three cases. First, if the traversal corresponds to the token staying still, then no edges are flipped and orienting the undirected edge will bring an increase of in the load. Second, if is an endpoint of a traversal and also a starting point of one (and we are not in the previous case), then the flipped edges cancel each other out and the orienting of the undirected edge will increase the load by . Finally, if is not the starting point but is an endpoint of a traversal, then turning the edges will increase the load by one. That covers all cases, yielding the lemma. ∎
In the end of a phase, there are no directed edges with badness larger than .
We approach the proof by induction. For the first phase, the claim follows by observing that for each node , at most one edge is directed towards . Consider now some phase where the badness of each directed edge is initially bounded by . Suppose for a contradiction that in the end of the phase, there is an edge with badness at least . First, consider the case that was unoriented in the beginning of phase . Since proposes the endpoint with the smaller load, it must be the case that has the smaller load in the beginning of phase . According to Lemma 5.3, the load of a node cannot decrease and can increase by at most yielding a contradiction.
Then, consider the case that edge was oriented in some previous phase for the first time. According to the induction assumption, the badness of edge was at most in the beginning of phase . According to Lemma 5.3, the load of a node can only increase by one per phase and hence, it must be the case that was oriented from to in the beginning of phase . Furthermore, since the badness increased from to , we have that node was an endpoint of a traversal and that was unoccupied in the end of the token dropping game in phase . Also, was not traversed, because it is still oriented towards in the end of phase (and would have been flipped otherwise). However, due to the design of our protocol, edge was a part of the token dropping game and hence, node not having a token violates the maximality of the token dropping game. This completes the inductive step and the claim follows by induction. ∎
The number of phases is .
Consider an arbitrary undirected edge . In every phase, sends a proposal to either or . Suppose w.l.o.g., that receives the proposal. Since accepts at least one proposal it receives, we have that at least one unoriented edge incident on becomes oriented. Hence, after phases, edge has to be oriented since in each phase before becomes oriented, at least one of the edges incident to or and different from has to change from unoriented to oriented. ∎
Proof of Theorem 5.1.
By Lemma 5.2, the token dropping instances we create in every phase are of height at most . Hence, by Theorem 4.1, we get that it takes rounds to execute one phase of our algorithm. Combining this with Lemma 5.5, we get a runtime bound of communication rounds. The correctness of the algorithm is given by Lemma 5.4. ∎
6 Linear-in- lower bound for stable orientations
In this section, we show that finding a stable orientation takes rounds. Recall that a tree where every non-leaf node has degree is called a -ary tree. Moreover, a perfect -ary tree is a -ary tree where all leaves are at the same depth. The height of a node is its distance to the closest leaf node; if is a leaf, then .
Let be a perfect -ary tree. In any stable orientation, .
Let denote the children of . Consider an arbitrary stable orientation of . We show by induction on the height that . The claim follows from this. Consider nodes at height . The base case is trivial, as leaves have no children. Let be a node with Suppose . As has only one parent, at least one child must have its edge pointed at . By the induction assumption we know that for every child it holds that . This implies that the edge is unhappy and therefore that the orientation of is not stable. ∎
Let be an oriented -regular graph. Then there exists a node such that .
For the sake of contradiction, suppose the claim does not hold. The sum over all nodes will then yield a result strictly smaller than . However, in any -regular graph the number of edges is given by . Thus, we obtain a contradiction as
Any algorithm that finds a stable orientation has a running time of rounds.
Fix and suppose there exists an algorithm that outputs a stable orientation in rounds. Fix a -regular graph with girth at least ; for sufficiently large such graphs exist. Consider the orientation produced by in . By Lemma 6.2, there exists some that has in this orientation.
Next, let be a perfect -ary tree of depth . Pick a node such that . Let denote the -radius neighborhood of node in graph . Clearly, and are isomorphic, as the -radius neighborhoods of and are -ary trees and indistinguishable. Hence, produces the same output for and , i.e., . By Lemma 6.1, any orientation output by in satisfies . Thus, we have that
which is a contradiction, thus yielding the claim. ∎
7 Stable assignments
In this section, we study the stable assignment problem. Recall that in this problem, we have customers on one side of a bipartition and servers on the other and the task of the customers is to choose exactly one server such that the load of the server is minimized. The selection of servers is stable if no customer has an incentive to change their choice. Also, recall that the stable orientation problem is a special case of the stable assignment problem, where each customer has degree . Throughout the section, we denote the maximum customer degree by and the maximum server degree by , and we use to denote the maximum degree in the entire network. We give two results on the stable assignment problem.
First, in Sections 7.2 and 7.1, we show that the proposal algorithm and the scheme of gradually orienting edges are robust to higher customer degrees. We interpret the bipartite input graph as a hypergraph, where the customers act as hyperedges. We define the token dropping game on hypergraphs and explain how to adapt the arguments from the case of rank customers to solve the hypergraph version. Then, we show how to gradually orient hyperedges such that the badness of any hyperedge is at most in the end of each phase.
Second, in Section 7.3, we will study a relaxation of the stable assignment problem. We consider the variant where all loads above a certain threshold are considered equal, and we will show that already with very small thresholds, this problem is at least as hard as maximal matching. Furthermore, we give an algorithm with a strictly faster runtime than what we obtained for the general version.
7.1 Token dropping for stable assignment
An oriented hyperedge is an edge where one node has the special role of the head of the edge. The other nodes in the hyperedge are oriented towards this edge, i.e., serve the role of the tail of the hyperedge. We generalize the token dropping game by adapting all definitions and rules in the natural way. In particular:
For each hyperedge with head , we have . For two endpoints of a hyperedge , we say that is a parent of and a child of (in hyperedge ) if is the head of , and . A token can only be passed by the head of some hyperedge to one of its children in the hyperedge—analogously to before, this process includes that the hyperedge is consumed. The three rules of (hyper)edge-disjoint traversals, unique destinations, and maximal traversals hold analogously.
The proposal algorithm.
Similarly to the case of rank , unoccupied nodes propose to a parent with a token, and occupied nodes pass a token to a child that made a proposal (to the node). The proofs of Lemmas 4.4, 4.2 and 4.5 can be adapted in a straight-forward manner. To see why a node can be active for at most rounds, as promised in Lemma 4.4, one needs to observe that each hyperedge has only one head and that the whole hyperedge is consumed when a token is passed through it. Hence, each parent (of which there are at most ) needs to be proposed to at most times. By the adapted lemmas, we obtain the same result for the hypergraph setting as for the case of customers of degree .
There is an algorithm that solves the token dropping game in rounds, where is the height of the game.
7.2 Finding a stable assignment
Gradually orienting edges.
Similarly to the case of rank , our plan is to divide the execution of our algorithm into phases and to guarantee a maximum badness of at most at the end of every phase, where the badness of a hyperedge with head is defined as . In each phase, every unoriented hyperedge makes a proposal to the node with the smallest load and exactly one proposal is accepted by any node that received at least one proposal. Then the algorithm proceeds as described in Section 5, where flipping an edge now corresponds to changing the head of a hyperedge: if, in the token dropping game, a token was passed from node to node via hyperedge , then the head of changes from to .
As before, the token dropping instance is created from hyperedges with badness exactly and all nodes and the tokens are added to the nodes that accepted a proposal. Now, all the statements from Section 5 can be generalized in a straightforward manner. For the generalization of Lemma 5.5, we obtain a slightly worse bound than for Lemma 5.5, as shown in Lemma 7.2. Then, Theorem 7.3 follows from Theorem 7.1 and Lemma 7.2.
The number of phases is at most .
Consider an arbitrary hyperedge of a hypergraph . In every phase, if is not yet oriented, sends a proposal to one of its nodes. This node must accept a proposal from at least one of its nodes. Since the rank of is at most and the maximum degree of a node is at most , there can be at most phases until is oriented itself, or all edges incident to the nodes of are oriented, which implies that becomes oriented in the next phase at the latest. ∎
There is an algorithm that solves the stable assignment problem in communication rounds in the LOCAL model.
7.3 Relaxations of the stable assignment problem
An interesting variant of the stable assignment problem is obtained by considering all possible loads above a certain threshold as being the same: after all, if the server has too high of a load, the customer might not care anymore how high the load is exactly, and instead looks for another solution. From a theoretical point of view, we might hope to solve these relaxations faster than the original stable assignment problem; in particular, the linear-in- lower bound presented in Section 6 weakens proportionally to the chosen threshold until we remain with a constant lower bound for relaxations with a constant threshold. While it is an intriguing open question how much the stable assignment problem becomes easier by introducing such a threshold, we show in Theorem 7.4 that even in the most relaxed non-trivial case, i.e., if we consider all loads strictly above as equal, we cannot hope for a better than linear dependency on . Formally, for each , the -bounded stable assignment problem is defined as the original stable assignment problem with the only difference that customers are only unhappy if they have chosen a server with indegree , but also have a neighbor of load at most . In particular, in the -bounded stable assignment problem, the only unhappy customers are those that have a neighbor with indegree , but have chosen a server with indegree at least . Due to space limitations, the proofs from this section are deferred to the appendix.
There is no deterministic algorithm that solves the -bounded stable assignment problem in rounds in the LOCAL model.
Similarly to the proof of Theorem 4.6, we use a reduction from the bipartite maximal matching problem to the -bounded stable assignment problem in order to obtain the desired lower bound. Consider a bipartite graph that is an input instance to the maximal matching problem and let . Now, first we find a solution to the -bounded stable assignment problem on , where the nodes in are the customers, the nodes in are the servers, and we interpret the edges which connect a customer with the chosen server as our (preliminary set of) matching edges. Then, each server with more than one incident edge in the preliminary matching keeps exactly one of those edges as a matching edge, and removes all of the others from the preliminary matching. In the following we show that the resulting edge set is a correct solution to the maximal matching problem.
The correctness of the output to the -bounded stable assignment problem and the post-processing step ensure that each node is matched to at most one other node. Now consider an unmatched customer node . Node is unmatched because the chosen server removed the connecting edge from the matching, for which must have had another incident edge in the preliminary matching. This implies that in the solution to the -bounded stable assignment problem, must have had load at least , which in turn implies that has no neighbor of load in that solution. Hence, every neighbor of is matched in the preliminary matching, and hence also in the final matching (which allows to be unmatched).
Finally, consider an unmatched server node . Node must have had load in the solution to the -bounded stable assignment problem, and therefore each neighbor of must have chosen a server of load at most , according to the definition of the -bounded stable assignment problem. This implies that for each neighbor of , the incident edge in the preliminary matching must also be in the final matching as load- servers do not remove any incident edge from the preliminary matching. Hence, being unmatched does not violate the maximal matching constraints.
This concludes the description of the reduction. Since the post-processing step only takes round of additional communication, and the bipartite maximal matching problem cannot be solved in rounds [BBH19], the same holds for the -bounded stable assignment problem. ∎
As for any , any solution to the -bounded stable assignment problem is also a solution to the -bounded stable assignment problem, the above lower bound also holds for the -bounded stable assignment problem, for all .
There is a deterministic algorithm that solves the -bounded stable assignment problem in communication rounds in the LOCAL model.
In essence, our algorithm is an adaptation of our scheme for the high customer degree case in Sections 7.2 and 7.1. However, for all notions defined via the indegree, such as the badness of a hyperedge, we instead use the effective indegree which is defined as the minimum of the indegree and . Moreover, we will use another protocol than the one in Section 7.1 to solve the token dropping instances generated during the algorithm. The rest of the algorithm is identical to the one used in this section to compute stable assignments in the unrelaxed setting: We split our algorithm into phases in the same way as in Section 7.2. Every customer proposes to the incident server with the minimum effective indegree and every server accepts exactly one of the received proposals if it received at least one proposal. We create a token dropping instance from all customers with badness exactly , assign nodes to levels according to their loads, and assign tokens to the servers that accepted a proposal.
We obtain a token dropping instance with levels; moreover, importantly, the indegree of any node in level is , since any such node has load . These observations will allow us to solve the token dropping instance in rounds, by using a different token dropping algorithm than before—essentially, we use the algorithm presented in the proof of Theorem 4.7. The only difference is that the up to children that a level node has are all endpoints of the unique hyperedge of which is the head. However, this simply implies that as soon as passes a token to a child, loses all its children which only helps the runtime. Hence, we obtain the same upper bound of as in Theorem 4.7 for solving the token dropping game.
- [ÅS10] Matti Åstrand and Jukka Suomela. Fast distributed approximation algorithms for vertex cover and set cover in anonymous networks. In Proc. 22nd ACM Symposium on Parallelism in Algorithms and Architectures (SPAA 2010), pages 294–302. ACM Press, 2010.
- [BBH19] Alkida Balliu, Sebastian Brandt, Juho Hirvonen, Dennis Olivetti, Mikaël Rabie, and Jukka Suomela. Lower bounds for maximal matchings and maximal independent sets. In Proc. 60th Annual IEEE Symposium on Foundations of Computer Science (FOCS 2019), pages 481–497. IEEE, 2019.
Sebastian Brandt, Orr Fischer, Juho Hirvonen, Barbara Keller, Tuomo
Lempiäinen, Joel Rybicki, Jukka Suomela, and Jara Uitto.
A lower bound for the distributed Lovász local lemma.
Proc. 48th ACM Symposium on Theory of Computing (STOC 2016), pages 479–488. ACM Press, 2016.
- [Bra19] Sebastian Brandt. An Automatic Speedup Theorem for Distributed Problems. In Proc. 38th ACM Symposium on Principles of Distributed Computing (PODC 2019), pages 379–388. ACM Press, 2019.
- [CHSW12] Andrzej Czygrinow, Michal Hanćkowiak, Edyta Szymańska, and Wojciech Wawrzyniak. Distributed 2-Approximation Algorithm for the Semi-matching Problem. In Proc. 26th International Conference on Distributed Computing (DISC 2012), pages 210–222, 2012.
- [CKP16] Yi-Jun Chang, Tsvi Kopelowitz, and Seth Pettie. An Exponential Separation between Randomized and Deterministic Complexity in the LOCAL Model. In Proc. 57th IEEE Symposium on Foundations of Computer Science (FOCS 2016), pages 615–624. IEEE, 2016.
- [CV86] Richard Cole and Uzi Vishkin. Deterministic coin tossing with applications to optimal parallel list ranking. Information and Control, 70(1):32–53, 1986.
- [FHS15] Laurent Feuilloley, Juho Hirvonen, and Jukka Suomela. Locally optimal load balancing. In Proc. 29th International Symposium on Distributed Computing (DISC 2015). Springer, 2015.
- [GHK17] Mohsen Ghaffari, Juho Hirvonen, Fabian Kuhn, Yannic Maus, Jukka Suomela, and Jara Uitto. Improved distributed degree splitting and edge coloring. In Proc. 31st International Symposium on Distributed Computing (DISC 2017), volume 91 of Leibniz International Proceedings in Informatics (LIPIcs), pages 19:1–19:15. Schloss Dagstuhl–Leibniz-Zentrum für Informatik, 2017.
- [GHS17] Mika Göös, Juho Hirvonen, and Jukka Suomela. Linear-in- lower bounds in the LOCAL model. Distributed Computing, 30(5):325–338, 2017.
- [GPS88] Andrew V. Goldberg, Serge A. Plotkin, and Gregory E. Shannon. Parallel Symmetry-Breaking in Sparse Graphs. SIAM Journal on Discrete Mathematics, 1(4):434–446, 1988.
- [GS17] Mohsen Ghaffari and Hsin-Hao Su. Distributed Degree Splitting, Edge Coloring, and Orientations. In Proc. 28th ACM-SIAM Symposium on Discrete Algorithms (SODA 2017), pages 2505–2523. Society for Industrial and Applied Mathematics, 2017.
- [HKP98] Michal Hanckowiak, Michal Karonski, and Alessandro Panconesi. On the Distributed Complexity of Computing Maximal Matchings. In Proc. 9th Annual ACM-SIAM Symposium on Discrete Algorithms (SODA 1998), pages 219–225. ACM/SIAM, 1998.
- [HLLT06] Nicholas J.A. Harvey, Richard E. Ladner, László Lovász, and Tami Tamir. Semi-matchings for bipartite graphs and load balancing. Journal of Algorithms, 59(1):53–78, 2006.
- [Lin92] Nathan Linial. Locality in Distributed Graph Algorithms. SIAM Journal on Computing, 21(1):193–201, 1992.
- [Nao91] Moni Naor. A lower bound on probabilistic algorithms for distributive ring coloring. SIAM Journal on Discrete Mathematics, 4(3):409–412, 1991.
- [NS95] Moni Naor and Larry Stockmeyer. What Can be Computed Locally? SIAM Journal on Computing, 24(6):1259–1277, 1995.
- [Oli19] Dennis Olivetti. Round Eliminator: a tool for automatic speedup simulation, 2019.
- [Pel00] David Peleg. Distributed Computing: A Locality-Sensitive Approach. Society for Industrial and Applied Mathematics, 2000.