arXiv subjects

Fabian Kuhn

Publications and source records attributed to Fabian Kuhn.

At least 73 records · Page 4Linked to original sources

arXiv2019

Distributed Computation in Node-Capacitated Networks

In this paper, we study distributed graph algorithms in networks in which the nodes have a limited communication capacity. Many distributed systems are built on top of an underlying networking infrastructure, for example by using a virtual communication topology known as an overlay network. Although this underlying network might allow each node to directly communicate with a large number of other nodes, the amount of communication that a node can perform in a fixed amount of time is typically much more limited. We introduce the Node-Capacitated Clique model as an abstract communication model, which allows us to study the effect of nodes having limited communication capacity on the complexity of distributed graph computations. In this model, the $n$ nodes of a network are connected as a clique and communicate in synchronous rounds. In each round, every node can exchange messages of $O(\log n)$ bits with at most $O(\log n)$ other nodes. When solving a graph problem, the input graph $G$ is defined on the same set of $n$ nodes, where each node knows which other nodes are its neighbors in $G$. To initiate research on the Node-Capacitated Clique model, we present distributed algorithms for the Minimum Spanning Tree (MST), BFS Tree, Maximal Independent Set, Maximal Matching, and Vertex Coloring problems. We show that even with only $O(\log n)$ concurrent interactions per node, the MST problem can still be solved in polylogarithmic time. In all other cases, the runtime of our algorithms depends linearly on the arboricity of $G$, which is a constant for many important graph families such as planar graphs.

cs.DC↗

arXiv2019

Improved Distributed Degree Splitting and Edge Coloring

The degree splitting problem requires coloring the edges of a graph red or blue such that each node has almost the same number of edges in each color, up to a small additive discrepancy. The directed variant of the problem requires orienting the edges such that each node has almost the same number of incoming and outgoing edges, again up to a small additive discrepancy. We present deterministic distributed algorithms for both variants, which improve on their counterparts presented by Ghaffari and Su [SODA'17]: our algorithms are significantly simpler and faster, and have a much smaller discrepancy. This also leads to a faster and simpler deterministic algorithm for $(2+o(1))Δ$-edge-coloring, improving on that of Ghaffari and Su.

cs.DC↗

arXiv2018

Optimal Gradient Clock Synchronization in Dynamic Networks

We study the problem of clock synchronization in highly dynamic networks, where communication links can appear or disappear at any time. The nodes in the network are equipped with hardware clocks, but the rate of the hardware clocks can vary arbitrarily within specific bounds, and the estimates that nodes can obtain about the clock values of other nodes are inherently inaccurate. Our goal in this setting is to output a logical clock at each node such that the logical clocks of any two nodes are not too far apart, and nodes that remain close to each other in the network for a long time are better synchronized than distant nodes. This property is called gradient clock synchronization. Gradient clock synchronization has been widely studied in the static setting, where the network topology does not change. We show that the asymptotically optimal bounds obtained for the static case also apply to our highly dynamic setting: if two nodes remain at distance $d$ from each other for sufficiently long, it is possible to upper bound the difference between their clock values by $O(d \log (D / d))$, where $D$ is the diameter of the network. This is known to be optimal even for static networks. Furthermore, we show that our algorithm has optimal stabilization time: when a path of length $d$ appears between two nodes, the time required until the clock skew between the two nodes is reduced to $O(d \log (D / d))$ is $O(D)$, which we prove to be optimal. Finally, the techniques employed for the more intricate analysis of the algorithm for dynamic graphs provide additional insights that are also of interest for the static setting. In particular, we establish self-stabilization of the gradient property within $O(D)$ time.

cs.DC↗

arXiv2018

Local Distributed Algorithms in Highly Dynamic Networks

The present paper studies local distributed graph problems in highly dynamic networks. Communication and changes of the graph happen in synchronous rounds and our algorithms always, i.e., in every round, satisfy non-trivial guarantees, no matter how dynamic the network is. We define a (in our view) natural generalization of static graph problems to the dynamic graph setting. Throughout the execution of an algorithm we consider a sliding window over the last $T$, e.g., polylogarithmic, rounds. Then, in some round, the feasibility of an output only depends on the topology of the graphs in the current sliding window and we call a feasible output a $T$-dynamic solution. The guarantees of a $T$-dynamic solution become stronger the more stable the graph is during this sliding window and, in particular, they coincide with the definition of the static graph problem if the graph is static throughout the window. We further present an abstract framework that allows to develop algorithms that output $T$-dynamic solutions in all rounds. The resulting algorithms have another desirable property: If a constant neighborhood around some part of the graph is stable during an interval $[t_1,t_2]$, the algorithms compute a static solution for this part of the graph throughout the interval $[t_1+T',t_2]$ for some (small) $T'>0$. We demonstrate our generic framework with two sample problems that abstract basic operations in dynamic networks, namely $\textit{(degree+1)-vertex coloring}$ and $\textit{maximal independent set (MIS)}$. To illustrate the given guarantees consider the vertex coloring problem: The sliding window of our (randomized) algorithm is of length $T=O(\log n)$ and any conflict between two nodes caused by a newly inserted edge is resolved within that time. During this conflict resolving both nodes always output colors that are not in conflict with their respective 'old' neighbors.

cs.DS↗

arXiv2018

The Communication Cost of Information Spreading in Dynamic Networks

This paper investigates the message complexity of distributed information spreading (a.k.a gossip or token dissemination) in adversarial dynamic networks, where the goal is to spread $k$ tokens of information to every node on an $n$-node network. We consider the amortized (average) message complexity of spreading a token, assuming that the number of tokens is large. Our focus is on token-forwarding algorithms, which do not manipulate tokens in any way other than storing, copying, and forwarding them. We consider two types of adversaries that arbitrarily rewire the network while keeping it connected: the adaptive adversary that is aware of the status of all the nodes and the algorithm (including the current random choices), and the oblivious adversary that is oblivious to the random choices made by the algorithm. The central question that motivates our work is whether one can achieve subquadratic amortized message complexity for information spreading. We present two sets of results depending on how nodes send messages to their neighbors: (1) Local broadcast: We show a tight lower bound of $Ω(n^2)$ on the number of amortized local broadcasts, which is matched by the naive flooding algorithm, (2) Unicast: We study the message complexity as a function of the number of dynamic changes in the network. To facilitate this, we introduce a natural complexity measure for analyzing dynamic networks called adversary-competitive message complexity where the adversary pays a unit cost for every topological change. Under this model, it is shown that if $k$ is sufficiently large, we can obtain an optimal amortized message complexity of $O(n)$. We also present a randomized algorithm that achieves subquadratic amortized message complexity when the number of tokens is not large under an oblivious adversary.

cs.DC↗

arXiv2018

Deterministic Distributed Ruling Sets of Line Graphs

An $(α,β)$-ruling set of a graph $G=(V,E)$ is a set $R\subseteq V$ such that for any node $v\in V$ there is a node $u\in R$ in distance at most $β$ from $v$ and such that any two nodes in $R$ are at distance at least $α$ from each other. The concept of ruling sets can naturally be extended to edges, i.e., a subset $F\subseteq E$ is an $(α,β)$-ruling edge set of a graph $G=(V,E)$ if the corresponding nodes form an $(α,β)$-ruling set in the line graph of $G$. This paper presents a simple deterministic, distributed algorithm, in the $\mathsf{CONGEST}$ model, for computing $(2,2)$-ruling edge sets in $O(\log^* n)$ rounds. Furthermore, we extend the algorithm to compute ruling sets of graphs with bounded diversity. Roughly speaking, the diversity of a graph is the maximum number of maximal cliques a vertex belongs to. We devise $(2,O(\mathcal{D}))$-ruling sets on graphs with diversity $\mathcal{D}$ in $O(\mathcal{D}+\log^* n)$ rounds. This also implies a fast, deterministic $(2,O(\ell))$-ruling edge set algorithm for hypergraphs with rank at most $\ell$. Furthermore, we provide a ruling set algorithm for general graphs that for any $B\geq 2$ computes an $\big(α, α\lceil \log_B n \rceil \big)$-ruling set in $O(α\cdot B \cdot \log_B n)$ rounds in the $\mathsf{CONGEST}$ model. The algorithm can be modified to compute a $\big(2, β\big)$-ruling set in $O(βΔ^{2/β} + \log^* n)$ rounds in the $\mathsf{CONGEST}$~ model, which matches the currently best known such algorithm in the more general $\mathsf{LOCAL}$ model.

cs.DS↗

arXiv2018

Efficient Distributed Computation of MIS and Generalized MIS in Linear Hypergraphs

Given a graph, a maximal independent set (MIS) is a maximal subset of pairwise non-adjacent vertices. Finding an MIS is a fundamental problem in distributed computing. Although the problem is extensively studied and well understood in simple graphs, our knowledge is still quite limited when solving it in hypergraphs, especially in the distributed CONGEST model. In this paper, we focus on linear hypergraphs---a class of hypergraphs in which any two hyperedges overlap on at most one node. We first present a randomized algorithm for computing an MIS in linear hypergraphs. It has poly-logarithmic runtime and it works in the CONGEST model. The algorithm uses a network decomposition to achieve fast parallel processing. Within each cluster of the decomposition, we run a distributed variant of a parallel hypergraph MIS algorithm by Luczak and Szymanska. We then propose the concept of a generalized maximal independent set (GMIS) as an extension to the classical MIS in hypergraphs. More specifically, in a GMIS, for each hyperedge $e$ in a hypergraph $\mathcal{H}$, we associate an integer threshold $t_e$ in the range $[1, |e|-1]$, and the goal is to find a maximal subset $\mathcal{I}$ of vertices that do not violate any threshold constraints: $\forall e \in E(\mathcal{H}), |e \cap \mathcal{I}| \leq t_e$. We hope that GMIS might capture a broader class of real-world problems than MIS; we also believe that GMIS is an interesting and challenging symmetry breaking problem on its own. Our second upper bound result is a distributed algorithm for computing a GMIS in linear hypergraphs, subject to the constraint that the maximum hyperedge size is bounded by some constant. Again, the algorithm has poly-logarithmic runtime and it works in the CONGEST model. It is obtained by generalizing our previous (linear) hypergraph MIS algorithm.

cs.DC↗

arXiv2017

Deterministic Distributed Edge-Coloring with Fewer Colors

We present a deterministic distributed algorithm, in the LOCAL model, that computes a $(1+o(1))Δ$-edge-coloring in polylogarithmic-time, so long as the maximum degree $Δ=\tildeΩ(\log n)$. For smaller $Δ$, we give a polylogarithmic-time $3Δ/2$-edge-coloring. These are the first deterministic algorithms to go below the natural barrier of $2Δ-1$ colors, and they improve significantly on the recent polylogarithmic-time $(2Δ-1)(1+o(1))$-edge-coloring of Ghaffari and Su [SODA'17] and the $(2Δ-1)$-edge-coloring of Fischer, Ghaffari, and Kuhn [FOCS'17], positively answering the main open question of the latter. The key technical ingredient of our algorithm is a simple and novel gradual packing of judiciously chosen near-maximum matchings, each of which becomes one of the color classes.

cs.DS↗

arXiv2017

On the Complexity of Local Distributed Graph Problems

This paper is centered on the complexity of graph problems in the well-studied LOCAL model of distributed computing, introduced by Linial [FOCS '87]. It is widely known that for many of the classic distributed graph problems (including maximal independent set (MIS) and $(Δ+1)$-vertex coloring), the randomized complexity is at most polylogarithmic in the size $n$ of the network, while the best deterministic complexity is typically $2^{O(\sqrt{\log n})}$. Understanding and narrowing down this exponential gap is considered to be one of the central long-standing open questions in the area of distributed graph algorithms. We investigate the problem by introducing a complexity-theoretic framework that allows us to shed some light on the role of randomness in the LOCAL model. We define the SLOCAL model as a sequential version of the LOCAL model. Our framework allows us to prove completeness results with respect to the class of problems which can be solved efficiently in the SLOCAL model, implying that if any of the complete problems can be solved deterministically in $\log^{O(1)} n$ rounds in the LOCAL model, we can deterministically solve all efficient SLOCAL-problems (including MIS and $(Δ+1)$-coloring) in $\log^{O(1)} n$ rounds in the LOCAL model. We show that a rather rudimentary looking graph coloring problem is complete in the above sense: Color the nodes of a graph with colors red and blue such that each node of sufficiently large polylogarithmic degree has at least one neighbor of each color. The problem admits a trivial zero-round randomized solution. The result can be viewed as showing that the only obstacle to getting efficient determinstic algorithms in the LOCAL model is an efficient algorithm to approximately round fractional values into integer values.

cs.DS↗

arXiv2017

Nearest Common Ancestors: Universal Trees and Improved Labeling Schemes

We investigate the nearest common ancestor (NCA) function in rooted trees. As the main conceptual contribution, the paper introduces universal trees for the NCA function: For a given family of rooted trees, an NCA-universal tree $S$ is a rooted tree such that any tree $T$ of the family can be embedded into $S$ such that the embedding of the NCA in $T$ of two nodes of $T$ is equal to the NCA in $S$ of the embeddings of the two nodes. As the main technical result we give explicit constructions of NCA-universal trees of size $n^{2.318}$ for the family of rooted $n$-vertex trees and of size $n^{1.894}$ for the family of rooted binary $n$-vertex trees. A direct consequence is the explicit construction of NCA-labeling schemes with labels of size $2.318\log_2 n$ and $1.894\log_2 n$ for the two families of rooted trees. This improves on the best known such labeling schemes established by Alstrup, Halvorsen and Larsen [SODA 2014].

cs.DS↗

arXiv2017

Dynamic Analysis of the Arrow Distributed Directory Protocol in General Networks

The Arrow protocol is a simple and elegant protocol to coordinate exclusive access to a shared object in a network. The protocol solves the underlying distributed queueing problem by using path reversal on a pre-computed spanning tree (or any other tree topology simulated on top of the given network). It is known that the Arrow protocol solves the problem with a competitive ratio of O(log D) on trees of diameter D. This implies a distributed queueing algorithm with competitive ratio O(s*log D) for general networks with a spanning tree of diameter D and stretch s. In this work we show that when running the Arrow protocol on top of the well-known probabilistic tree embedding of Fakcharoenphol, Rao, and Talwar [STOC 03], we obtain a randomized distributed queueing algorithm with a competitive ratio of O(log n) even on general network topologies. The result holds even if the queueing requests occur in an arbitrarily dynamic and concurrent fashion and even if communication is asynchronous. From a technical point of view, the main of the paper shows that the competitive ratio of the Arrow protocol is constant on a special family of tree topologies, known as hierarchically well separated trees.

cs.DS↗

arXiv2017

Deterministic Distributed Edge-Coloring via Hypergraph Maximal Matching

We present a deterministic distributed algorithm that computes a $(2Δ-1)$-edge-coloring, or even list-edge-coloring, in any $n$-node graph with maximum degree $Δ$, in $O(\log^7 Δ\log n)$ rounds. This answers one of the long-standing open questions of \emph{distributed graph algorithms} from the late 1980s, which asked for a polylogarithmic-time algorithm. See, e.g., Open Problem 4 in the Distributed Graph Coloring book of Barenboim and Elkin. The previous best round complexities were $2^{O(\sqrt{\log n})}$ by Panconesi and Srinivasan [STOC'92] and $\tilde{O}(\sqrtΔ) + O(\log^* n)$ by Fraigniaud, Heinrich, and Kosowski [FOCS'16]. A corollary of our deterministic list-edge-coloring also improves the randomized complexity of $(2Δ-1)$-edge-coloring to poly$(\log\log n)$ rounds. The key technical ingredient is a deterministic distributed algorithm for \emph{hypergraph maximal matching}, which we believe will be of interest beyond this result. In any hypergraph of rank $r$ --- where each hyperedge has at most $r$ vertices --- with $n$ nodes and maximum degree $Δ$, this algorithm computes a maximal matching in $O(r^5 \log^{6+\log r } Δ\log n)$ rounds. This hypergraph matching algorithm and its extensions lead to a number of other results. In particular, a polylogarithmic-time deterministic distributed maximal independent set algorithm for graphs with bounded neighborhood independence, hence answering Open Problem 5 of Barenboim and Elkin's book, a $((\log Δ/\varepsilon)^{O(\log (1/\varepsilon))})$-round deterministic algorithm for $(1+\varepsilon)$-approximation of maximum matching, and a quasi-polylogarithmic-time deterministic distributed algorithm for orienting $λ$-arboricity graphs with out-degree at most $(1+\varepsilon)λ$, for any constant $\varepsilon>0$, hence partially answering Open Problem 10 of Barenboim and Elkin's book.

cs.DS↗

arXiv2017

Communication Primitives in Cognitive Radio Networks

Cognitive radio networks are a new type of multi-channel wireless network in which different nodes can have access to different sets of channels. By providing multiple channels, they improve the efficiency and reliability of wireless communication. However, the heterogeneous nature of cognitive radio networks also brings new challenges to the design and analysis of distributed algorithms. In this paper, we focus on two fundamental problems in cognitive radio networks: neighbor discovery, and global broadcast. We consider a network containing $n$ nodes, each of which has access to $c$ channels. We assume the network has diameter $D$, and each pair of neighbors have at least $k\geq 1$, and at most $k_{max}\leq c$, shared channels. We also assume each node has at most $Δ$ neighbors. For the neighbor discovery problem, we design a randomized algorithm CSeek which has time complexity $\tilde{O}((c^2/k)+(k_{max}/k)\cdotΔ)$. CSeek is flexible and robust, which allows us to use it as a generic "filter" to find "well-connected" neighbors with an even shorter running time. We then move on to the global broadcast problem, and propose CGCast, a randomized algorithm which takes $\tilde{O}((c^2/k)+(k_{max}/k)\cdotΔ+D\cdotΔ)$ time. CGCast uses CSeek to achieve communication among neighbors, and uses edge coloring to establish an efficient schedule for fast message dissemination. Towards the end of the paper, we give lower bounds for solving the two problems. These lower bounds demonstrate that in many situations, CSeek and CGCast are near optimal.

cs.DC↗

arXiv2016

Multi-Message Broadcast in Dynamic Radio Networks

We continue the recent line of research studying information dissemination problems in adversarial dynamic radio networks. We give two generic algorithms which allow to transform generalized version of single-message broadcast algorithms into multi-message broadcast algorithms. Based on these generic algorithms, we obtain multi-message broadcast algorithms for dynamic radio networks for a number of different dynamic network settings. For one of the modeling assumptions, our algorithms are complemented by a lower bound which shows that the upper bound is close to optimal.

cs.DC↗

arXiv2016

Polynomial Lower Bound for Distributed Graph Coloring in a Weak LOCAL Model

We show an $Ω\big(Δ^{\frac{1}{3}-\fracη{3}}\big)$ lower bound on the runtime of any deterministic distributed $\mathcal{O}\big(Δ^{1+η}\big)$-graph coloring algorithm in a weak variant of the \LOCAL\ model. In particular, given a network graph \mbox{$G=(V,E)$}, in the weak \LOCAL\ model nodes communicate in synchronous rounds and they can use unbounded local computation. We assume that the nodes have no identifiers, but that instead, the computation starts with an initial valid vertex coloring. A node can \textbf{broadcast} a \textbf{single} message of \textbf{unbounded} size to its neighbors and receives the \textbf{set of messages} sent to it by its neighbors. That is, if two neighbors of a node $v\in V$ send the same message to $v$, $v$ will receive this message only a single time; without any further knowledge, $v$ cannot know whether a received message was sent by only one or more than one neighbor. Neighborhood graphs have been essential in the proof of lower bounds for distributed coloring algorithms, e.g., \cite{linial92,Kuhn2006On}. Our proof analyzes the recursive structure of the neighborhood graph of the respective model to devise an $Ω\big(Δ^{\frac{1}{3}-\fracη{3}}\big)$ lower bound on the runtime for any deterministic distributed $\mathcal{O}\big(Δ^{1+η}\big)$-graph coloring algorithm. Furthermore, we hope that the proof technique improves the understanding of neighborhood graphs in general and that it will help towards finding a lower (runtime) bound for distributed graph coloring in the standard \LOCAL\ model. Our proof technique works for one-round algorithms in the standard \LOCAL\ model and provides a simpler and more intuitive proof for an existing $Ω(Δ^2)$ lower bound.

cs.DC↗

arXiv2016

Local Computation: Lower and Upper Bounds

The question of what can be computed, and how efficiently, are at the core of computer science. Not surprisingly, in distributed systems and networking research, an equally fundamental question is what can be computed in a \emph{distributed} fashion. More precisely, if nodes of a network must base their decision on information in their local neighborhood only, how well can they compute or approximate a global (optimization) problem? In this paper we give the first poly-logarithmic lower bound on such local computation for (optimization) problems including minimum vertex cover, minimum (connected) dominating set, maximum matching, maximal independent set, and maximal matching. In addition we present a new distributed algorithm for solving general covering and packing linear programs. For some problems this algorithm is tight with the lower bounds, for others it is a distributed approximation scheme. Together, our lower and upper bounds establish the local computability and approximability of a large class of problems, characterizing how much local information is required to solve these tasks.

cs.DC↗

arXiv2016

The Cost of Global Broadcast in Dynamic Radio Networks

We study the single-message broadcast problem in dynamic radio networks. We show that the time complexity of the problem depends on the amount of stability and connectivity of the dynamic network topology and on the adaptiveness of the adversary providing the dynamic topology. More formally, we model communication using the standard graph-based radio network model. To model the dynamic network, we use a generalization of the synchronous dynamic graph model introduced in [Kuhn et al., STOC 2010]. For integer parameters $T\geq 1$ and $k\geq 1$, we call a dynamic graph $T$-interval $k$-connected if for every interval of $T$ consecutive rounds, there exists a $k$-vertex-connected stable subgraph. Further, for an integer parameter $τ\geq 0$, we say that the adversary providing the dynamic network is $τ$-oblivious if for constructing the graph of some round $t$, the adversary has access to all the randomness (and states) of the algorithm up to round $t-τ$. As our main result, we show that for any $T\geq 1$, any $k\geq 1$, and any $τ\geq 1$, for a $τ$-oblivious adversary, there is a distributed algorithm to broadcast a single message in time $O\big(\big(1+\frac{n}{k\cdot\min\left\{τ,T\right\}}\big)\cdot n\log^3 n\big)$. We further show that even for large interval $k$-connectivity, efficient broadcast is not possible for the usual adaptive adversaries. For a $1$-oblivious adversary, we show that even for any $T\leq (n/k)^{1-\varepsilon}$ (for any constant $\varepsilon>0$) and for any $k\geq 1$, global broadcast in $T$-interval $k$-connected networks requires at least $Ω(n^2/(k^2\log n))$ time. Further, for a $0$ oblivious adversary, broadcast cannot be solved in $T$-interval $k$-connected networks as long as $T<n-k$.

cs.DC↗

arXiv2015

Rumor Spreading with Bounded In-Degree

In the classic gossip-based model of communication for disseminating information in a network, in each time unit, every node $u$ is allowed to contact a single random neighbor $v$. If $u$ knows the data (rumor) to be disseminated, it disperses it to $v$ (known as PUSH) and if it does not, it requests it from $v$ (known as PULL). While in the classic gossip model, each node is only allowed to contact a single neighbor in each time unit, each node can possibly be contacted by many neighboring nodes. In the present paper, we consider a restricted model where at each node only one incoming request can be served. As long as only a single piece of information needs to be disseminated, this does not make a difference for push requests. It however has a significant effect on pull requests. In the paper, we therefore concentrate on this weaker pull version, which we call 'restricted pull'. We distinguish two versions of the restricted pull protocol depending on whether the request to be served among a set of pull requests at a given node is chosen adversarially or uniformly at random. As a first result, we prove an exponential separation between the two variants. We show that there are instances where if an adversary picks the request to be served, the restricted pull protocol requires a polynomial number of rounds whereas if the winning request is chosen uniformly at random, the restricted pull protocol only requires a polylogarithmic number of rounds to inform the whole network. Further, as the main technical contribution, we show that if the request to be served is chosen randomly, the slowdown of using restricted pull versus using the classic pull protocol can w.h.p. be upper bounded by $O(Δ/ δ\log n)$, where $Δ$ and $δ$ are the largest and smallest degree of the network.

cs.DC↗