DeepAI
Log In Sign Up

Sinkless orientation is hard also in the supported LOCAL model

We show that any algorithm that solves the sinkless orientation problem in the supported LOCAL model requires Ω(log n) rounds, and this is tight. The supported LOCAL is at least as strong as the usual LOCAL model, and as a corollary this also gives a new, short and elementary proof that shows that the round complexity of the sinkless orientation problem in the deterministic LOCAL model is Ω(log n).

READ FULL TEXT VIEW PDF

page 1

page 2

page 3

page 4

07/29/2019

Distributed Dense Subgraph Detection and Low Outdegree Orientation

The maximum density subgraph problem, introduced in the 80s by Picard an...
11/03/2022

Distributed Maximal Matching and Maximal Independent Set on Hypergraphs

We investigate the distributed complexity of maximal matching and maxima...
09/18/2019

Message Reduction in the Local Model is a Free Lunch

A new spanner construction algorithm is presented, working under the LOC...
12/09/2019

A Deterministic Algorithm for the MST Problem in Constant Rounds of Congested Clique

In this paper, we show that the Minimum Spanning Tree problem can be sol...
12/10/2021

Sleeping Model: Local and Dynamic Algorithms

In recent years the sleeping model came to the focus of researchers. In ...
05/12/2021

Locally Checkable Labelings with Small Messages

A rich line of work has been addressing the computational complexity of ...

1 Introduction

Sinkless orientations.

In the sinkless orientation problem, the task is to orient the edges of a graph such that all nodes of degree at least have out-degree at least . The problem is always solvable, and easy to solve in the centralized setting, but a lot more challenging to solve efficiently in distributed or parallel settings.

The sinkless orientation problem is the canonical example of a problem that has round complexity rounds in the randomized model but rounds in the deterministic model. It is a rare example of a locally checkable problem in which randomness helps exponentially, and also an example of a locally checkable problem with an intermediate complexity—not solvable in rounds but solvable in sub-diameter time.

Supported LOCAL model.

While the complexity landscape in the usual model is nowadays well understood [3, 5, 1, 4, 8, 7, 11, 10], and also some weaker models of distributed computing have been already explored [9, 14, 2], it has been wide open how the landscape changes when we switch to stronger models of computing. In this work we focus on the supported model, which is strictly stronger than the model.

In the supported model [15, 12], the communication network and the unique identifiers are all known to all nodes, and the input is a subgraph of . That is, each node receives as input the entire structure of the communication network , including all the unique identifiers, and a list of its incident edges in ; we refer to the latter edges as input edges. Otherwise, the computation proceeds as in the standard model, using all edges of for communication. In our case, we would like to find a sinkless orientation in the input graph .

The availability of the underlying globally-known communication graph (a.k.a. the support) helps a lot with many problems. For example, all locally checkable problems with complexity admit constant-time algorithms in the supported model—in essence, the support can be used to break symmetry for free [12]. Also if we had the promise that the support is a tree, then the sinkless orientation problem would become trivial: we can orient all edges of towards a leaf, and this orientation is also a valid orientation for any subgraph . However, in this work we show that this trick only works in trees—we show that if, for example, is a -regular graph, then the support is essentially useless.

The supported model was originally introduced in the context of software-defined networks (SDNs). The underlying idea is that the communication graph represents the unchanging physical network, and the input graph represents the logical state of the network to which the control plane (here, distributed algorithm) needs to respond to; see reference [15] for more details. However, supported have proven to be useful as a purely theoretical model for lower bounds (this work, Reference [12], and the very recent work of Haeupler et al. [13]).

Our contributions.

We prove that the round complexity of the sinkless orientation problem in the deterministic supported model is rounds. By prior work, we also know that this is tight: the problem is solvable in rounds (with or without support). Furthermore, the same problem can be solved in the randomized supported model in rounds.

In particular, we learn that in the supported model there are locally checkable problems in which randomness helps exponentially. As a corollary, we cannot use the support to efficiently derandomize algorithms.

The classic proof for the LOCAL model.

As a by-product, our work gives a new, short and elementary proof that shows that the round complexity of the sinkless orientation problem in the deterministic model is .

The standard proof is somewhat long and complicated. It builds on the round elimination technique [1, 8, 7], but round elimination has so far been unable to handle unique identifiers. Hence in prior work one has always taken a detour: first prove an lower bound in the randomized model without unique identifiers [8], and then apply the deterministic gap result of Chang et al. [10] to derive a deterministic lower bound.

Besides being complicated, the standard proof seems to be also fundamentally incompatible with the supported model. Hence until now it has remained open what is the computational complexity of the sinkless orientation in the supported model, and more generally whether there are any problems in the supported model where randomness helps exponentially.

Our new proof for the supported LOCAL model.

By switching to the supported model, we can give a direct proof without any detours through randomness and gap results. We directly show with elementary arguments that the complexity of sinkless orientation is , both in the usual model and also in the supported model.

The underlying idea is, in essence, the same as the ID graph technique from the very recent work by Brandt et al. [9]. The ID graph in their work plays a role similar to the support in our work. However, the details differ, as the goals are different. Brandt et al. aimed at proving a lower bound for randomized local computation algorithms, while our aim is at proving a lower bound for deterministic supported algorithms.

The key technical difference is that ID graphs [9] need to have a large chromatic number, while our proof goes through even if the support is a bipartite graph. On the other hand, we need to do more work in the base case when we argue that 0-round algorithms do not exist.

2 Sinkless orientation lower bound

Roadmap.

For technical convenience, we prove the result in a stronger bipartite version of the model. The lower bound in this setting then implies lower bounds for (non-bipartite) and supported , by observing that algorithms from a weaker model can be translated to the stronger models with no overhead in round complexity.

The overall structure of our lower bound proof is as follows. We fix a bipartite -regular graph with girth , and an assignment of unique identifiers on . We then show that in bipartite supported , any algorithm that solves sinkless orientation, even with the promise that the support graph is , requires rounds.

The proof has two main steps. First, we give a round elimination lemma showing that any -round sinkless orientation algorithm on can be converted into a -round algorithm, as long as sufficiently less than the girth of . By iterating this lemma, we can thus turn a -round algorithm into a -round algorithm. Second, we show that no such -round algorithm can exist, implying that any algorithm requires rounds.

2.1 Setup

Bipartite model.

In bipartite supported , we are given a promise that the support graph is bipartite, and a -coloring is given to the nodes as an input; we refer to the two colors as black and white. In the bipartite model, we consider either the black or white nodes to be active, and the other color to be passive. All nodes of the graph run an algorithm as per supported model; upon termination of the algorithm, the active nodes produce an output, and the passive nodes output nothing. The outputs of the active nodes must form a globally valid solution; in particular, in sinkless orientation, the outputs of the active nodes already orients all edges, and both active and passive nodes must not be sinks.

Sinkless orientation in bipartite model.

We encode sinkless orientation in the bipartite supported model as follows. Each active node outputs, for each incident input edge, one label from the alphabet . The edge-output indicates that the edge is outgoing from the active node, and the edge-output indicates it is incoming to the active node. An output is correct if for each active node of degree at least , there is at least one output on an incident input edge, and for each passive node of degree at least , there is at least one output on an incident input edge. Note that the labels represent orientation w.r.t. the active node, and we require each active node to have at least one label (indicating an outgoing edge), and each passive node to have at least one label (indicating an edge incoming to an active neighbor, thus outgoing from the passive node we consider). Hence, any solution on general graphs can immediately be translated to a solution in the bipartite model.

In more detail, consider a sinkless orientation algorithm running in rounds in (supported) model, with some reasonable output encoding. To turn this into a bipartite (supported) algorithm, one first runs algorithm in the bipartite model—this requires no modifications, as computation in the bipartite model is done exactly as in the original. After has terminated, (1) the passive nodes discard the output of and output nothing, and (2) the active nodes inspect the output of , and output for each incident edge directed towards them, and for each edge directed away from them in the output of . Since is a sinkless orientation algorithm, these outputs also guarantee that each passive node has one edge with output incident to it. In particular, it follows that lower bounds for bipartite algorithms are also lower bounds for the standard models.

2.2 Step one: Round elimination

Lemma 1.

Let be a fixed -regular bipartite graph with girth , and fixed unique identifiers and -coloring of the nodes. Let , and assume there is a -round algorithm that solves sinkless orientation on . Then there is a -round algorithm that solves sinkless orientation on .

Proof.

The proof proceeds by the standard round elimination strategy. Let us assume without loss of generality that black nodes are active in . For a non-negative integer and any node , let us denote by the nodes within distance from the node in the graph .

We construct an algorithm where white nodes are active. In algorithm , each white node performs the following steps:

  1. Node gathers the inputs in its -radius neighborhood .

  2. For each neighbor of , the node enumerates all possible input graphs on that are compatible with the actual input graph on . For each such , simulates to compute what output would output on the edge under input . Let denote the set of all possible outputs obtained for edge this way.

  3. If then outputs on , and otherwise it outputs on it.

We now prove produces a valid solution for sinkless orientation.

Consider a white node , and its two neighbors , in . Since , we have , and thus the inputs in do not affect the output of in , and likewise the inputs in do not affect the output of in . Thus, any combination of and may occur as an output: for any such and , there is an input graph such that in outputs for the edge , and outputs for the edge .

Let be a white node of degree at least in with neighbors in . By the above argument, for any choice of one for each neighbor of , there is an input graph on which outputs for the edge . If each contains , there would be an input graph on which outputs for all incident input edges of , rendering it incorrect. Hence, at least one neighbor of satisfies , and in where is active, outputs on the edge .

On the other hand, consider black node of degree at least with neighbors in . On the true input node in will output on an incident edge , for some . In , the node will consider the input on (among other inputs), so we have . Thus, in the node will output on , and has an incident edge labeled as desired. ∎

2.3 Step two: There exists no 0-round algorithm

Lemma 2.

Let be a fixed -regular bipartite graph with girth , and assume unique identifiers and -coloring on are fixed. There is no algorithm solving sinkless orientation in bipartite supported in  rounds on .

Proof.

Assume for contradiction that there is a 0-round algorithm with black nodes as active. Label each edge of by the set of all outputs can output for when is part of the input. For any black node , there must be at least three edges labeled with either or , as otherwise, for some input would have exactly three incident input edges on which it would output .

Since every edge is incident to exactly one black node, at most of the edges are labeled . Hence, there is a white node such that is incident to at least three edges , and labeled with either or . Now consider an input where these three edges are the only input edges incident to . Since the output of each node depends only on its incident input edges, we can select for each an input where outputs for edge . Moreover, since is a -round algorithm and nodes , and are not neighbors, we can do this for all of them simultaneously. Thus, there exists an input where outputs on all incident input edges of the passive node , a contradiction. ∎

2.4 Putting things together

Theorem 3.

Any deterministic algorithm solving sinkless orientation in the supported model requires rounds.

Proof.

Let be a bipartite 5-regular graph with girth . Observe that we can obtain one e.g. by taking the bipartite double cover of any -regular graph of girth , which are known to exist (see e.g., [6, Ch. 3]).

Assume that there is a supported algorithm that solves sinkless orientation in rounds on communication graph . This implies that there is a bipartite supported algorithm for sinkless orientation on running in time . By repeated application of Lemma 1, there is a sequence of bipartite supported algorithms

where algorithm solves sinkless orientation in rounds.

In particular, solves sinkless orientation in rounds. By Lemma 2, this is impossible, so algorithm cannot exist. ∎

Corollary 4.

Any deterministic algorithm solving sinkless orientation in the model requires rounds.

Proof.

Any algorithm that runs in rounds can be simulated in supported in rounds by ignoring non-input edges: simply run on the input graph . Thus, the claim follows immediately from Theorem 3. ∎

Acknowledgements

This research is supported by the European Research Council (ERC) under the European Union’s Horizon 2020 research and innovation programme (grant agreement No 805223 ScaleML), the Austrian Science Fund (FWF) and netIDEE SCIENCE project P 33775-N, and the Austrian Science Fund (FWF) project ADVISE, I 4800-N, 2020-2023.

References

  • [1] 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), 2019.
  • [2] Alkida Balliu, Sebastian Brandt, Dennis Olivetti, Jan Studený, Jukka Suomela, and Aleksandr Tereshchenko. Locally checkable problems in rooted trees. In Proc. 40th ACM Symposium on Principles of Distributed Computing (PODC 2021), 2021.
  • [3] Alkida Balliu, Sebastian Brandt, Dennis Olivetti, and Jukka Suomela. Almost global problems in the LOCAL model. In Proc. 32nd International Symposium on Distributed Computing (DISC 2018), 2018. doi:10.4230/LIPIcs.DISC.2018.9.
  • [4] Alkida Balliu, Sebastian Brandt, Dennis Olivetti, and Jukka Suomela. How much does randomness help with locally checkable problems? In Proc. 39th ACM Symposium on Principles of Distributed Computing (PODC 2020), 2020. doi:10.1145/3382734.3405715.
  • [5] Alkida Balliu, Juho Hirvonen, Janne H Korhonen, Tuomo Lempiäinen, Dennis Olivetti, and Jukka Suomela. New classes of distributed time complexity. In

    Proc. 50th ACM Symposium on Theory of Computing (STOC 2018)

    , 2018.
    doi:10.1145/3188745.3188860.
  • [6] Béla Bollobás. Extremal graph theory. Courier Corporation, 2004.
  • [7] Sebastian Brandt. An Automatic Speedup Theorem for Distributed Problems. In Proc. 38th ACM Symposium on Principles of Distributed Computing (PODC 2019), 2019. doi:10.1145/3293611.3331611.
  • [8] 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. In Proc. 48th ACM Symposium on Theory of Computing (STOC 2016), 2016. doi:10.1145/2897518.2897570.
  • [9] Sebastian Brandt, Christoph Grunau, and Václav Rozhoň. The randomized local computation complexity of the Lovász local lemma. In Proc. 40th ACM Symposium on Principles of Distributed Computing (PODC 2021), 2021.
  • [10] 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), 2016. doi:10.1109/FOCS.2016.72.
  • [11] Yi-Jun Chang and Seth Pettie. A Time Hierarchy Theorem for the LOCAL Model. SIAM Journal on Computing, 48(1):33–69, 2019. doi:10.1137/17M1157957.
  • [12] Klaus-Tycho Foerster, Juho Hirvonen, Stefan Schmid, and Jukka Suomela. On the Power of Preprocessing in Decentralized Network Optimization. In Proc. IEEE Conference on Computer Communications (INFOCOM 2019), 2019. doi:10.1109/INFOCOM.2019.8737382.
  • [13] Bernhard Haeupler, David Wajc, and Goran Zuzic. Universally-optimal distributed algorithms for known topologies. In STOC, pages 1166–1179. ACM, 2021.
  • [14] Will Rosenbaum and Jukka Suomela. Seeing Far vs. Seeing Wide: Volume Complexity of Local Graph Problems. In Proc. 39th ACM Symposium on Principles of Distributed Computing (PODC 2020), 2020. doi:10.1145/3382734.3405721.
  • [15] Stefan Schmid and Jukka Suomela. Exploiting locality in distributed SDN control. In Proc. ACM SIGCOMM Workshop on Hot Topics in Software Defined Networking (HotSDN 2013), pages 121–126. ACM Press, 2013. doi:10.1145/2491185.2491198.