No full-text available
To read the full-text of this research,
you can request a copy directly from the authors.
Local certification of graphs with bounded genus
Abstract
Naor, Parter, and Yogev [SODA 2020] recently designed a compiler for automatically translating standard centralized interactive protocols to distributed interactive protocols, as introduced by Kol, Oshman, and Saxena [PODC 2018]. In particular, by using this compiler, every linear-time algorithm for deciding the membership to some fixed graph class can be translated into a dMAM(O(logn)) protocol for this class, that is, a distributed interactive protocol with O(logn)-bit proof size in n-node graphs, and three interactions between the (centralized) computationally-unbounded but non-trustable prover Merlin, and the (decentralized) randomized computationally-limited verifier Arthur. As a corollary, there is a dMAM(O(logn)) protocol for recognizing the class of planar graphs, as well as for recognizing the class of graphs with bounded genus.
We show that there exists a distributed interactive protocol for recognizing the class of graphs with bounded genus performing just a single interaction, from the prover to the verifier, yet preserving proof size of O(logn) bits. This result also holds for the class of graphs with bounded non-orientable genus, that is, graphs that can be embedded on a non-orientable surface of bounded genus. The interactive protocols described in this paper are actually proof-labeling schemes, i.e., a subclass of interactive protocols, previously introduced by Korman, Kutten, and Peleg [PODC 2005]. In particular, these schemes do not require any randomization from the verifier, and the proofs may often be computed a priori, at low cost, by the nodes themselves. Our results thus extend the recent proof-labeling scheme for planar graphs by Feuilloley et al. [PODC 2020], to graphs of bounded genus, and to graphs of bounded non-orientable genus.
... In the domain of graph classes certi cation, there have been several results on various classes such as trees [28], bipartite graphs [25] or graphs of bounded diameter [7], but until two years ago little was known about essential classes, such as planar graphs, H-free or H-minor-free graphs. Recently, it has been shown that planar graphs and graphs of bounded genus can be certi ed with O(log n)-bit labels [14,19,20]. This size, O(log n), is the gold standard of certi cation, in the sense that little can be achieved with o(log n) bits, thus O(log n) is often the best we can hope for. ...
... Then it was proved in [19] that these graphs can actually be certi ed with O(log n) bits in the classic model, that is, without interaction. This result was extended to bounded-genus graphs in [20]. Later, [14] provided a simpler proof of both results via di erent techniques. ...
... Theorem 7 ( [20]). Consider an edge certi cation of a graph class C where the edges are labeled with f (n)-bit certi cates. ...
Local certification consists in assigning labels to the nodes of a network to certify that some given property is satisfied, in such a way that the labels can be checked locally. In the last few years, certification of graph classes received a considerable attention. The goal is to certify that a graph G belongs to a given graph class~. Such certifications with labels of size (where n is the size of the network) exist for trees, planar graphs and graphs embedded on surfaces. Feuilloley et al. ask if this can be extended to any class of graphs defined by a finite set of forbidden minors. In this work, we develop new decomposition tools for graph certification, and apply them to show that for every small enough minor H, H-minor-free graphs can indeed be certified with labels of size . We also show matching lower bounds with a simple new proof technique.
... Intuitively, a proof-labeling scheme is a protocol that certifies locally if a certain property holds on a network. By "locally," one means that each vertex v in the network has a partial view of the entire network, such as the set of vertices adjacent to v. If a graph satisfies a property P, then every vertex has to certify P, whereas if the graph does not satisfy the property then at least one vertex fails to certify P. Planar graphs and graphs of bounded genus have relatively straight forward proof-labeling schemes (see [13,14]). If a graph G can be embedded on a surface of genus g, then G has a proof-labeling whose complexity depends on g (see [12,14]). ...
... By "locally," one means that each vertex v in the network has a partial view of the entire network, such as the set of vertices adjacent to v. If a graph satisfies a property P, then every vertex has to certify P, whereas if the graph does not satisfy the property then at least one vertex fails to certify P. Planar graphs and graphs of bounded genus have relatively straight forward proof-labeling schemes (see [13,14]). If a graph G can be embedded on a surface of genus g, then G has a proof-labeling whose complexity depends on g (see [12,14]). ...
In this paper, we provide bounds for the genus of the pancake graph , burnt pancake graph , and undirected generalized pancake graph . Our upper bound for is sharper than the previously-known bound, and the other bounds presented are the first of their kind. Our proofs are constructive and rely on finding an appropriate rotation system (also referred to in the literature as Edmonds' permutation technique) where certain cycles in the graphs we consider become boundaries of regions of a 2-cell embedding. A key ingredient in the proof of our bounds for the genus and is a labeling algorithm of their vertices that allows us to implement rotation systems to bound the number of regions of a 2-cell embedding of said graphs.
... • Θ(1): this includes k-colorability for fixed k, and in particular bipartiteness; • Θ(log n): this includes non-bipartiteness, acyclicity; planarity [9] and more generally bounded genus [10,6]; • Θ(poly(n)): this includes non-3-colorability [14], unit-distance graphs, unitdisk graphs, and 1-planar graphs [3], as well as problems involving symmetries [14]. ...
Local certification is a topic originating from distributed computing, where a prover tries to convince the vertices of a graph G that G satisfies some property . To convince the vertices, the prover gives a small piece of information, called certificate, to each vertex, and the vertices then decide whether the property is satisfied by just looking at their certificate and the certificates of their neighbors. When studying a property in the perspective of local certification, the aim is to find the optimal size of the certificates needed to certify , which can be viewed a measure of the local complexity of . A certification scheme is considered to be efficient if the size of the certificates is polylogarithmic in the number of vertices. While there have been a number of meta-theorems providing efficient certification schemes for general graph classes, the proofs of the lower bounds on the size of the certificates are usually very problem-dependent. In this work, we introduce a notion of hardness reduction in local certification, and show that we can transfer a lower bound on the certificates for a property to a lower bound for another property , via a (local) hardness reduction from to . We then give a number of applications in which we obtain polynomial lower bounds for many classical properties using such reductions.
... More recently, there has been a new direction explored in local certification, which consists in designing proof-labeling schemes for properties of the network itself. For example, [12,17,18] design compact proof-labeling schemes for planar and bounded-genus graphs. In such setting, our notion of error-sensitivity is not relevant, as the distance is about the number of edits at the vertices, whereas for network properties, one should consider edits on the graph itself. ...
Proof-labeling schemes are known mechanisms providing nodes of networks with certificates that can be verified locally by distributed algorithms. Given a boolean predicate on network states, such schemes enable to check whether the predicate is satisfied by the actual state of the network, by having nodes interacting with their neighbors only. Proof-labeling schemes are typically designed for enforcing fault-tolerance, by making sure that if the current state of the network is illegal with respect to some given predicate, then at least one node will detect it. Such a node can raise an alarm, or launch a recovery procedure enabling the system to return to a legal state. In this paper, we introduce error-sensitive proof-labeling schemes. These are proof-labeling schemes which guarantee that the number of nodes detecting illegal states is linearly proportional to the edit-distance between the current state and the set of legal states. By using error-sensitive proof-labeling schemes, states which are far from satisfying the predicate will be detected by many nodes, enabling fast return to legality. We provide a structural characterization of the set of boolean predicates on network states for which there exist error-sensitive proof-labeling schemes. This characterization allows us to show that classical predicates such as, e.g., acyclicity, and leader admit error-sensitive proof-labeling schemes, while others like regular subgraphs don't. We also focus on compact error-sensitive proof-labeling schemes. In particular, we show that the known proof-labeling schemes for spanning tree and minimum spanning tree, using certificates on bits, and on bits, respectively, are error-sensitive, as long as the trees are locally represented by adjacency lists, and not just by parent pointers.
... Since local certification has been introduced, lower bounds and upper bounds for the size of the certificates for many graph properties and problems have been proven [5,2,9,15]. Also, the strength of the model in general and under various restrictions was studied [13,12,11]. ...
This paper deals with local certification, specifically locally checkable proofs: given a graph property, the task is to certify whether a graph satisfies the property. The verification of this certification needs to be done locally without the knowledge of the whole graph. More precisely, a distributed algorithm, called a verifier, is executed on each vertex. The verifier observes the local neighborhood up to a constant distance and either accepts or rejects. We examine the trade-off between the visibility radius and the size of certificates. We describe a procedure that decreases the radius by encoding the neighbourhood of each vertex into its certificate. We also provide a corresponding lower bound on the required certificate size increase, showing that such an approach is close to optimal.
... The best-known local certification is the certification of acyclicity (that is, the vertification of the class of trees) for which the optimal size is Θ(log n) (by a straightforward adaptation of [18,Lemma 2.2]). It has been proved recently that planarity and bounded-genus [12,11,8] have logarithmic certification, and that MSO properties on graphs of bounded treedepth [5] and bounded treewidth [15] have respectively Θ(log n) and O(log 2 n) local certifications. An important open question in the area is to establish whether any graph class defined by a set of forbidden minors has a compact certification. ...
Given a network property or a data structure, a local certification is a labeling that allows to efficiently check that the property is satisfied, or that the structure is correct. The quality of a certification is measured by the size of its labels: the smaller, the better.This notion plays a central role in self-stabilization, because the size of the certification is a lower bound (and often an upper bound) on the memory needed for silent self-stabilizing construction of distributed data structures. From the point of view of distributed computing in general, it is also a measure of the locality of a property (e.g. properties of the network itself, such as planarity). When it comes to the size of the certification labels, one can identify three important regimes: the properties for which the optimal size is polynomial in the number of vertices of the graph, the ones that require only polylogarithmic size, and the ones that can be certified with a constant number of bits. The first two regimes are well studied, with several upper and lower bounds, specific techniques, and active research questions. On the other hand, the constant regime has never been really explored, at least on the lower bound side. The main contribution of this paper is the first non-trivial lower bound for this low regime. More precisely, we show that by using certification on just one bit (a binary certification), one cannot certify k-colorability for . To do so, we develop a new technique, based on the notion of score, and both local symmetry arguments and a global parity argument. We hope that this technique will be useful for establishing stronger results. We complement this result by a discussion of the implication of lower bounds for this constant-size regime, and with an upper bound for a related problem, illustrating that in some cases one can do better than the natural upper bound.
... A certification with Θ(log ) bits is now called a compact local certification, and it has become the gold standard of the area. Recently, planarity and more generally embeddability on bounded-genus surfaces, and -minor-freeness for graphs of size at most 4, have been proved to have such compact certifications [8,19,25,26]. ...
Local certification consists in assigning labels (called \emph{certificates}) to the nodes of a network to certify a property of the network or the correctness of a data structure distributed on the network. The verification of this certification must be local: a node typically sees only its neighbors in the network. The main measure of performance of a certification is the size of its certificates. In 2011, G\"o\"os and Suomela identified as a special certificate size: below this threshold little is possible, and several key properties do have certifications of this type. A certification with such small certificates is now called a \emph{compact local certification}, and it has become the gold standard of the area, similarly to polynomial time for centralized computing. A major question is then to understand which properties have certificates, or in other words: what is the power of compact local certification? Recently, a series of papers have proved that several well-known network properties have compact local certifications: planarity, bounded-genus, etc. But one would like to have more general results, \emph{i.e.} meta-theorems. In the analogue setting of polynomial-time centralized algorithms, a very fruitful approach has been to prove that restricted types of problems can be solved in polynomial time in graphs with restricted structures. These problems are typically those that can be expressed in some logic, and the graph structures are whose with bounded width or depth parameters. We take a similar approach and prove the first meta-theorems for local certification. (See the abstract of the pdf for more details.)
... We already know the existence of PLSs (with logarithmic size certificates) for the recognition of many graph classes such as acyclic graphs [31], planar graphs [13], graphs with bounded genus [12], graph classes defined by a finite set of forbidden minors [5], etc. ...
A graph G=(V,E) is a geometric intersection graph if every node is identified with a geometric object of some particular type, and two nodes are adjacent if the corresponding objects intersect. Geometric intersection graph classes have been studied from both the theoretical and practical point of view. On the one hand, many hard problems can be efficiently solved or approximated when the input graph is restricted to a geometric intersection class of graphs. On the other hand, these graphs appear naturally in many applications such as sensor networks, scheduling problems, and others. Recently, in the context of distributed certification and distributed interactive proofs, the recognition of graph classes has started to be intensively studied. Different results related to the recognition of trees, bipartite graphs, bounded diameter graphs, triangle-free graphs, planar graphs, bounded genus graphs, H-minor free graphs, etc., have been obtained. The goal of the present work is to design efficient distributed protocols for the recognition of relevant geometric intersection graph classes, namely permutation graphs, trapezoid graphs, circle graphs, and polygon-circle graphs. More precisely, for the two first classes, we give proof labeling schemes recognizing them with logarithmic-sized certificates. For the other two classes, we give three-round distributed interactive protocols that use messages and certificates of size . Finally, we provide logarithmic lower-bounds on the size of the certificates on the proof labeling schemes for the recognition of any of the aforementioned geometric intersection graph classes.
... As a consequence, Θ(log n) has been identi ed as the standard for compact (or e cient) certi cation. Recently, planarity and more generally embeddability on bounded-genus surfaces, and H-minor-freeness for speci c H, have been proved to have such compact certi cations [7,14,19,20]. Unfortunately, not every property has a compact certi cation. ...
The graph model checking problem consists in testing whether an input graph satisfies a given logical formula. In this paper, we study this problem in a distributed setting, namely local certification. The goal is to assign labels to the nodes of a network to certify that some given property is satisfied, in such a way that the labels can be checked locally. We first investigate which properties can be locally certified with small certificates. Not surprisingly, this is almost never the case, except for not very expressive logic fragments. Following the steps of Courcelle-Grohe, we then look for meta-theorems explaining what happens when we parameterize the problem by some standard measures of how simple the graph classes are. In that direction, our main result states that any MSO formula can be locally certified on graphs with bounded treedepth with a logarithmic number of bits per node, which is the golden standard in certification.
... There are many interesting graph classes, and establishing the certificate size for those is a vast program. In [33] and [31], the authors proved that certifying planarity and embeddability on bounded genus graphs can be done with certificates of size O(log n). Note that these classes can be characterized by forbidden minors, and that the language that we know have large certificates (e.g. ...
A distributed graph algorithm is basically an algorithm where every node of a
graph can look at its neighborhood at some distance in the graph and chose its
output. As distributed environment are subject to faults, an important issue is
to be able to check that the output is correct, or in general that the network
is in proper configuration with respect to some predicate. One would like this
checking to be very local, to avoid using too much resources. Unfortunately
most predicates cannot be checked this way, and that is where certification
comes into play. Local certification (also known as proof-labeling schemes,
locally checkable proofs or distributed verification) consists in assigning
labels to the nodes, that certify that the configuration is correct. There are
several point of view on this topic: it can be seen as a part of
self-stabilizing algorithms, as labeling problem, or as a non-deterministic
distributed decision.
This paper is an introduction to the domain of local certification, giving an
overview of the history, the techniques and the current research directions.
... This work could find extensions in many directions, fitting with the aforementioned interest of the distributed computing community for classes of sparse graphs beyond planar graphs (see [17]). For instance, we have recently generalized the results in this paper to the design of proof-labeling schemes for the classes of graphs with bounded genus, as well as for the classes of graphs with bounded oriented genus, still using certificates on O(log n) bits [21]. We also point out the recent result [15] that establishes the same results as ours, but using different techniques. ...
Naor M., Parter M., Yogev E.: (The power of distributed verifiers in interactive proofs. In: 31st ACM-SIAM symposium on discrete algorithms (SODA), pp 1096–115, 2020. https://doi.org/10.1137/1.9781611975994.67) have recently demonstrated the existence of a distributed interactive proof for planarity (i.e., for certifying that a network is planar), using a sophisticated generic technique for constructing distributed IP protocols based on sequential IP protocols. The interactive proof for planarity is based on a distributed certification of the correct execution of any given sequential linear-time algorithm for planarity testing. It involves three interactions between the prover and the randomized distributed verifier (i.e., it is a dMAM protocol), and uses small certificates, on O(logn) bits in n-node networks. We show that a single interaction with the prover suffices, and randomization is unecessary, by providing an explicit description of a proof-labeling scheme for planarity, still using certificates on just O(logn) bits. We also show that there are no proof-labeling schemes—in fact, even no locally checkable proofs—for planarity using certificates on o(logn) bits.
... Also, the structural properties of distance-hereditary graphs have been used in the design of compact routing tables for interconnection networks [5]. Regarding local certification, other results on the recognition of graph classes include planar graphs [14] and graphs with bounded genus [13], where the authors showed that both classes admit proof-labeling schemes with logarithmic-sized certificates. Recently, Naor, Parter and Yogev defined in [35] a compiler which (1) turns any problem solved in NP in time τ (n) into a dMAM protocol using private randomness and bandwidth τ (n) log n/n and; (2) turns any problem which can be solved in NC into a dAM protocol with private randomness, poly log n rounds of interaction and bandwidth poly log n. ...
We present compact distributed interactive proofs for the recognition of two important graph classes, well-studied in the context of centralized algorithms, namely complement reducible graphs and distance-hereditary graphs. Complement reducible graphs (also called cographs) are defined as the graphs not containing a four-node path as an induced subgraph. Distance-hereditary graphs are a super-class of cographs, defined as the graphs where the distance (shortest paths) between any pair of vertices is the same on every induced connected subgraph. First, we show that there exists a distributed interactive proof for the recognition of cographs with two rounds of interaction. More precisely, we give a protocol with a proof size of bits that uses shared randomness and recognizes cographs with high probability. Moreover, our protocol can be adapted to verify any Turing-decidable predicate restricted to cographs in with certificates of size . Second, we give a three-round, interactive protocol for the recognition of distance-hereditary graphs, still with a proof size of bits and also using shared randomness. Finally, we show that any one-round (denoted ) or two-round, protocol for the recognition of cographs or distance-hereditary graphs requires certificates of size bits. Moreover, we show that any constant-round protocol using shared randomness requires certificates of size .
In the LOCAL model, low-diameter decomposition is a useful tool in designing algorithms, as it allows us to shift from the general graph setting to the low-diameter graph setting, where brute-force information gathering can be done efficiently. Recently, Chang and Su [PODC 2022] showed that any high-conductance network excluding a fixed minor contains a high-degree vertex, so the entire graph topology can be gathered to one vertex efficiently in the CONGEST model using expander routing. Therefore, in networks excluding a fixed minor, many problems that can be solved efficiently in LOCAL via low-diameter decomposition can also be solved efficiently in CONGEST via expander decomposition. In this work, we show improved decomposition and routing algorithms for networks excluding a fixed minor in the CONGEST model. Our algorithms cost rounds deterministically. For bounded-degree graphs, our algorithms finish in rounds. Our algorithms have a wide range of applications, including the following results in CONGEST. 1. A -approximate maximum independent set in a network excluding a fixed minor can be computed deterministically in rounds, nearly matching the lower bound of Lenzen and Wattenhofer [DISC 2008]. 2. Property testing of any additive minor-closed property can be done deterministically in rounds if is a constant or rounds if the maximum degree is a constant, nearly matching the lower bound of Levi, Medina, and Ron [PODC 2018].
Given a network property or a data structure, a local certification is a labeling that allows to efficiently check that the property is satisfied, or that the structure is correct. The quality of a certification is measured by the size of its labels: the smaller, the better. This notion plays a central role in self-stabilization, because the size of the certification is a lower bound (and often an upper bound) on the memory needed for silent self-stabilizing construction of distributed data structures.When it comes to the size of the certification labels, one can identify three important regimes: the properties for which the optimal size is polynomial in the number of vertices of the graph, the ones that require only polylogarithmic size, and the ones that can be certified with a constant number of bits. The first two regimes are well studied, with several upper and lower bounds, specific techniques, and active research questions. On the other hand, the constant regime has never been really explored.The main contribution of this paper is the first non-trivial lower bound for this low regime. More precisely, we show that by using certification on just one bit (a binary certification), one cannot certify k-colorability for . To do so, we develop a new technique, based on the notion of score, and both local symmetry arguments and a global parity argument. We hope that this technique will be useful for establishing stronger results.We complement this result with an upper bound for a related problem, illustrating that in some cases one can do better than the natural upper bound.
Proof-labeling schemes are known mechanisms providing nodes of networks with certificates that can be verified locally by distributed algorithms. Given a boolean predicate on network states, such schemes enable to check whether the predicate is satisfied by the actual state of the network, by having nodes interacting with their neighbors only. Proof-labeling schemes are typically designed for enforcing fault-tolerance, by making sure that if the current state of the network is illegal with respect to some given predicate, then at least one node will detect it. Such a node can raise an alarm, or launch a recovery procedure enabling the system to return to a legal state.
In this paper, we introduce error-sensitive proof-labeling schemes. These are proof-labeling schemes which guarantee that the number of nodes detecting illegal states is linearly proportional to the Hamming distance between the current state and the set of legal states. By using error-sensitive proof-labeling schemes, states which are far from satisfying the predicate will be detected by many nodes. We provide a structural characterization of the set of boolean predicates on network states for which there exist error-sensitive proof-labeling schemes. This characterization allows us to show that classical predicates such as, e.g., cycle-freeness, and leader admit error-sensitive proof-labeling schemes, while others like regular subgraphs do not. We also focus on compact error-sensitive proof-labeling schemes. In particular, we show that the known proof-labeling schemes for spanning tree and minimum spanning tree, using certificates on O(logn) bits, and on O(log2n) bits, respectively, are error-sensitive, as long as the trees are locally represented by adjacency lists, and not just by parent pointers.
Naor M., Parter M., Yogev E.: (The power of distributed verifiers in interactive proofs. In: 31st ACM-SIAM symposium on discrete algorithms (SODA), pp 1096–115, 2020. https://doi.org/10.1137/1.9781611975994.67) have recently demonstrated the existence of a distributed interactive proof for planarity (i.e., for certifying that a network is planar), using a sophisticated generic technique for constructing distributed IP protocols based on sequential IP protocols. The interactive proof for planarity is based on a distributed certification of the correct execution of any given sequential linear-time algorithm for planarity testing. It involves three interactions between the prover and the randomized distributed verifier (i.e., it is a dMAM protocol), and uses small certificates, on O(logn) bits in n-node networks. We show that a single interaction with the prover suffices, and randomization is unecessary, by providing an explicit description of a proof-labeling scheme for planarity, still using certificates on just O(logn) bits. We also show that there are no proof-labeling schemes—in fact, even no locally checkable proofs—for planarity using certificates on o(logn) bits.
Proof-labeling schemes, introduced by Korman et al. (Distrib Comput 22(4):215–233, 2010. https://doi.org/10.1007/s00446-010-0095-3), are a mechanism to certify that a network configuration satisfies a given boolean predicate. Such mechanisms find applications in many contexts, e.g., the design of fault-tolerant distributed algorithms. In a proof-labeling scheme, predicate verification consists of neighbors exchanging labels, whose contents depends on the predicate. In this paper, we introduce the notion of randomized proof-labeling schemes where messages are randomized and correctness is probabilistic. We show that randomization reduces verification complexity exponentially while guaranteeing probability of correctness arbitrarily close to one. We also present a novel message-size lower bound technique that applies to deterministic as well as randomized proof-labeling schemes. Using this technique, we establish several tight bounds on the verification complexity of MST, acyclicity, connectivity, and longest cycle size.
Distributed proofs are mechanisms enabling the nodes of a network to collectivity and efficiently check the correctness of Boolean predicates on the structure of the network, or on data-structures distributed over the nodes (e.g., spanning trees or routing tables). We consider mechanisms consisting of two components: a \emph{prover} assigning a \emph{certificate} to each node, and a distributed algorithm called \emph{verifier} that is in charge of verifying the distributed proof formed by the collection of all certificates. In this paper, we show that many network predicates have distributed proofs offering a high level of redundancy, explicitly or implicitly. We use this remarkable property of distributed proofs for establishing perfect tradeoffs between the \emph{size of the certificate} stored at every node, and the \emph{number of rounds} of the verification protocol. If we allow every node to communicate to distance at most t, one might expect that the certificate sizes can be reduced by a multiplicative factor of at least~t. In trees, cycles and grids, we show that such tradeoffs can be established for \emph{all} network predicates, i.e., it is always possible to linearly decrease the certificate size. In arbitrary graphs, we show that any part of the certificates common to all nodes can be evenly redistributed among these nodes, achieving even a better tradeoff: this common part of the certificate can be reduced by the size of a smallest ball of radius t in the network. In addition to these general results, we establish several upper and lower bounds on the certificate sizes used for distributed proofs for spanning trees, minimum-weight spanning trees, diameter, additive and multiplicative spanners, and more, improving and generalizing previous results from the literature.
The Minimum Dominating Set (MDS) problem is a fundamental and challenging problem in distributed computing. While it is well known that minimum dominating sets cannot be well approximated locally on general graphs, in recent years there has been much progress on computing good local approximations on sparse graphs and in particular on planar graphs. In this article, we study distributed and deterministic MDS approximation algorithms for graph classes beyond planar graphs. In particular, we show that existing approximation bounds for planar graphs can be lifted to bounded genus graphs and more general graphs, which we call locally embeddable graphs, and present
(1) a local constant-time, constant-factor MDS approximation algorithm on locally embeddable graphs, and
(2) a local O(log*n)-time (1+ε)-approximation scheme for any ε > 0 on graphs of bounded genus.
Our main technical contribution is a new analysis of a slightly modified variant of an existing algorithm by Lenzen et al. [21]. Interestingly, unlike existing proofs for planar graphs, our analysis does not rely on direct topological arguments but on combinatorial density arguments only.
For planar graphs on n nodes we show how to construct in linear time shortest path routing tables that require 8n + o(n) bits per node, and O(log2+∈
n) bit-operations per node to extract the route, with constant ∈ > 0. We generalize the result for every graph of bounded crossing-edge number. We also extend our result to any graph of
genus bounded by γ, by building shortest path routing tables of n log (γ + 1)+ O(n) bits per node, and with O(log2+∈
n) bit-operations per node to extract the route. This result is obtained by the use of dominating sets, compact coding of non-crossing
partitions, and k-page representation of graphs.
This paper addresses the problem of locally verifying global properties. Several natural questions are studied, such as “how
expensive is local verification?” and more specifically, “how expensive is local verification compared to computation?” A
suitable model is introduced in which these questions are studied in terms of the number of bits a vertex needs to communicate.
The model includes the definition of a proof labeling scheme (a pair of algorithms- one to assign the labels, and one to use
them to verify that the global property holds). In addition, approaches are presented for the efficient construction of schemes,
and upper and lower bounds are established on the bit complexity of schemes for multiple basic problems. The paper also studies
the role and cost of unique identities in terms of impossibility and complexity, in the context of proof labeling schemes.
Previous studies on related questions deal with distributed algorithms that simultaneously compute a configuration and verify
that this configuration has a certain desired property. It turns out that this combined approach enables the verification
to be less costly sometimes, since the configuration is typically generated so as to be easily verifiable. In contrast, our
approach separates the configuration design from the verification. That is, it first generates the desired configuration without
bothering with the need to verify it, and then handles the task of constructing a suitable verification scheme. Our approach
thus allows for a more modular design of algorithms, and has the potential to aid in verifying properties even when the original
design of the structures for maintaining them was done without verification in mind.
KeywordsDistributed networks-Proof labels-Property verification-Self stabilization
This paper concerns compact routing schemes with arbitrary node names. We present a compact name-independent routing scheme
for unweighted networks with n nodes excluding a fixed minor. For any fixed minor, the scheme, constructible in polynomial time, has constant stretch factor
and requires routing tables with poly-logarithmic number of bits at each node.
For shortest-path labeled routing scheme in planar graphs, we prove an Ω(n
ε
) space lower bound for some constant ε > 0. This lower bound holds even for bounded degree triangulations, and is optimal for polynomially weighted planar graphs
(ε=1/2).
Whether local algorithms can compute constant approximations of NP-hard problems is of both practical and theoretical interest. So far, no algorithms achieving this goal are known, as either the ap- proximation ratio or the running time exceed O(1), or the nodes are provided with non-trivial additional information. In this pa- per, we present the first distributed algorithm approximating a min- imum dominating set on a planar graph within a constant factor in constant time. Moreover, the nodes do not need any additional information.
This paper presents a lower boundof Ω( D + √ n/ log n) on the time requiredfor the distributed construction of a minimum-weight spanning tree (MST) in weighted n-vertex networks of diameter D = Ω(log n), in the bounded message model. This establishes the asymptotic near- optimality of existing time-efficient distributed algorithms for the problem, whose complexity is O(D + √ n log∗ n).
Distributed certification, whether it be proof-labeling schemes, locally checkable proofs, etc., deals with the issue of certifying the legality of a distributed system with respect to a
given boolean predicate. A certificate is assigned to each process in the system by a non-trustable oracle, and the processes are in charge of verifying these certificates, so that two properties are satisfied: completeness, i.e., for every legal instance, there is a certificate assignment leading all processes to accept, and soundness, i.e., for every illegal instance, and for every certificate assignment, at least one process rejects. The verification of the certificates must be fast, and the certificates themselves must be small. A large quantity of results have been produced in this framework, each aiming at designing a distributed certification mechanism for specific boolean predicates. This paper presents a “meta-theorem”, applying to many boolean predicates at once. Specifically, we prove that, for every boolean predicate on graphs definable in the monadic second-order (MSO) logic of graphs, there exists a distributed certification mechanism using certificates on bits in n-node graphs of bounded treewidth, with a verification protocol involving a single round of communication between neighbors.KeywordsProof-labeling schemeLocally checkable proofFault-toleranceDistributed decision
Approximate proof labeling schemes were introduced by Censor-Hillel, Paz and Perry [3]. Roughly speaking, a graph property P can be verified by an approximate proof labeling scheme in constant-time if the vertices of a graph having the property can be convinced, in a short period of time not depending on the size of the graph, that they are having the property P or at least they are not far from being having the property P. The main result of this paper is that bounded-degree planar graphs (and also outer-planar graphs, bounded genus graphs, knotlessly embeddable graphs etc.) can be verified by an approximate proof labeling scheme in constant-time.
A proof labelling scheme for a graph class C is an assignment of certificates to the vertices of any graph in the class C, such that upon reading its certificate and the certificates of its neighbors, every vertex from a graph G∈C accepts the instance, while if G∉C, for every possible assignment of certificates, at least one vertex rejects the instance. It was proved recently that for any fixed surface Σ, the class of graphs embeddable in Σ has a proof labelling scheme in which each vertex of an n-vertex graph receives a certificate of at most O(logn) bits. The proof is quite long and intricate and heavily relies on an earlier result for planar graphs. Here we give a very short proof for any surface. The main idea is to encode a rotation system locally, together with a spanning tree supporting the local computation of the genus via Euler's formula.
We show that there exists an adjacency labelling scheme for planar graphs where each vertex of an n -vertex planar graph G is assigned a (1 + o(1)) log 2 n -bit label and the labels of two vertices u and v are sufficient to determine if uv is an edge of G . This is optimal up to the lower order term and is the first such asymptotically optimal result. An alternative, but equivalent, interpretation of this result is that, for every positive integer n , there exists a graph U n with n 1+o(1) vertices such that every n -vertex planar graph is an induced subgraph of U n . These results generalize to a number of other graph classes, including bounded genus graphs, apex-minor-free graphs, bounded-degree graphs from minor closed families, and k -planar graphs.
In a distributed locally-checkable proof, we are interested in checking the legality of a given network configuration with respect to some Boolean predicate. To do so, the network enlists the help of a prover—a computationally-unbounded oracle that aims at convincing the network that its state is legal, by providing the nodes with certificates that form a distributed proof of legality. The nodes then verify the proof by examining their certificate, their local neighborhood and the certificates of their neighbors.
In the framework of distributed network computing, it is known that not all Turing-decidable predicates on labeled networks can be decided locally whenever the computing entities are Turing machines (TM). This holds even if nodes are running non-deterministic Turing machines (NTM). In contrast, we show that every Turing-decidable predicate on labeled networks can be decided locally if nodes are running alternating Turing machines (ATM). More specifically, we show that, for every such predicate, there is a local algorithm for ATMs, with at most two alternations, that decides whether the actual labeled network satisfies that predicate. To this aim, we define a hierarchy of classes of decision tasks, where the lowest level contains tasks solvable with TMs, the first level those solvable with NTMs, and the level k>1 contains those tasks solvable with ATMs with k−1 alternations. We characterize the entire hierarchy, and show that it collapses in the second level.
Interactive proof systems allow a resource-bounded verifier to decide an intractable language (or compute a hard function) by communicating with a powerful but untrusted prover. Such systems guarantee that the prover can only convince the verifier of true statements. In the context of centralized computation, a celebrated result shows that interactive proofs are extremely powerful, allowing polynomial-time verifiers to decide any language in PSPACE. In this work we initiate the study of interactive distributed proofs : a network of nodes interacts with a single untrusted prover, who sees the entire network graph, to decide whether the graph satisfies some property. We focus on the communication cost of the protocol --- the number of bits the nodes must exchange with the prover and each other. Our model can also be viewed as a generalization of the various models of "distributed NP'' (proof labeling schemes, etc.) which received significant attention recently: while these models only allow the prover to present each network node with a string of advice, our model allows for back-and-forth interaction. We prove both upper and lower bounds for the new model. We show that for some problems, interaction can exponentially decrease the communication cost compared to a non-interactive prover, but on the other hand, some problems retain non-trivial cost even with interaction.
We study a new model of verification of boolean predicates over distributed networks. Given a network configuration, the proof-labeling scheme (PLS) model defines a distributed proof in the form of a label that is given to each node, and all nodes locally verify that the network configuration satisfies the desired boolean predicate by exchanging labels with their neighbors. The proof size of the scheme is defined to be the maximum size of a label.
In this work, we extend this model by defining the approximate proof-labeling scheme (APLS) model. In this new model, the predicates for verification are of the form ψ≤φ, where ψ,φ:F→N for a family of configurations F. Informally, the predicates considered in this model are a comparison between two values of the configuration. As in the PLS model, nodes exchange labels in order to locally verify the predicate, and all must accept if the network satisfies the predicate. The soundness condition is relaxed with an approximation ration α, so that only if ψ>αφ some node must reject.
We focus on two verification problems: upper and lower bounds on the diameter of the graph, and the maximality of a given matching. For these problems, we present the first results that apply to all graph structures. In our new APLS model, we show that the proof size can be much smaller than the proof size of the same predicate in the PLS model. Moreover, we prove that there is a tradeoff between the approximation ratio and the proof size. Finally, we present the first general result for maximum cardinality matching in the PLS model.
\noindent We provide a new constant factor approximation algorithm for the (connected) \mboxdistance- r dominating set problem on graph classes of bounded expansion. Classes of bounded expansion include many familiar classes of sparse graphs such as planar graphs and graphs with excluded (topological) minors, and notably, these classes form the most general subgraph closed classes of graphs for which a sequential constant factor approximation algorithm for the distance- r dominating set problem is currently known. Our algorithm can be implemented in the \congestbc model of distributed computing and uses communication rounds. % Our techniques, which may be of independent interest, are based on a distributed computation of sparse neighborhood covers of small radius on bounded expansion classes. We show how to compute an r -neighborhood cover of radius~2r and overlap f(r) on every class of bounded expansion in communication rounds for some function~ f .% in the \congestbc model. % Finally, we show how to use the greater power of the łocal model to turn any distance- r dominating set into a constantly larger connected distance- r dominating set in 3r+1 rounds on any class of bounded expansion. Combining this algorithm, e.g., with the constant factor approximation algorithm for dominating sets on planar graphs of Lenzen et al.\ gives a constant factor approximation algorithm for connected dominating sets on planar graphs in a constant number of rounds in the łocal model, where the approximation ratio is only 6 times larger than that of Lenzen et al.'s algorithm.
In this paper we consider a generalization of the classical dominating set problem to the k-tuple dominating set problem (kMDS). For any positive integer k, we look for a smallest subset of vertices D ⊆ V with the property that every vertex in V ∖ D is adjacent to at least k vertices of D. We are interested in the distributed complexity of this problem in the model, where the nodes have no identifiers. The most challenging case is when k = 2, and for this case we propose a distributed local algorithm, which runs in a constant number of rounds, yielding a 7-approximation in the class of planar graphs. On the other hand, in the class of algorithms in which every vertex uses only its degree and the degree of its neighbors to make decisions, there is no algorithm providing a (5 − ε)-approximation of the 2MDS problem. In addition, we show a lower bound of (4 − ε) for the 2MDS problem even if unique identifiers are allowed.
For k ≥ 3, we show that for the problem kMDS in planar graphs, a trivial algorithm yields a k/(k − 2)-approximation. In the model with unique identifiers this, surprisingly, is optimal for k = 3,4,5, and 6, as we provide a matching lower bound.
In this paper we consider the 2-dominating set problem (2MDS). We look for a smallest subset of vertices with the property that every vertex in is adjacent to at least 2 vertices of D. We are interested in the distributed complexity of this problem in the local model, where the nodes have no identifiers but there is a port ordering available. We propose a distributed local (constant time) algorithm yielding a 6-approximation in the class of planar graphs. Earlier result shows that in this case, for any , there is no deterministic distributed local/constant-round algorithm providing a -approximation of the 2MDS.
This paper presents the first (non-trivial) distributed planar embedding algorithm. We consider this a crucial first step in a broader program to design efficient distributed algorithms for planar networks. We work in the standard distributed model in which nodes can send an O(log n)-bit message to each of their neighbors per round. In a planar network, with n nodes and diameter D, our deterministic planar embedding algorithm uses O(D dot min{log n, D) rounds to compute a combinatorial planar embedding, which consists of each node knowing the clockwise order of its incident edges in a fixed planar drawing. The complexity of our algorithm is near-optimal and matches the trivial lower bound of Omega(D) up to a log n factor. No algorithm outperforming the trivial round complexity of O(n) was known prior to this work.
The Minimum Dominating Set (MDS) problem is not only one of the most fundamental problems in distributed computing, it is also one of the most challenging ones. While it is well-known that minimum dominating sets cannot be approximated locally on general graphs, over the last years, several breakthroughs have been made on computing local approximations on sparse graphs.
This paper presents a deterministic and local constant factor approximation for minimum dominating sets on bounded genus graphs, a large family of sparse graphs. Our main technical contribution is a new analysis of a slightly modified variant of an existing algorithm by Lenzen et al. Interestingly, unlike existing proofs for planar graphs, our analysis does not rely on direct topological arguments. We believe that our techniques can be useful for the study of local problems on sparse graphs beyond the scope of this paper.
We extend the notion of distributed decision in the framework of distributed network computing, inspired by recent results on so-called distributed graph automata. We show that, by using distributed decision mechanisms based on the interaction between a prover and a disprover, the size of the certificates distributed to the nodes for certifying a given network property can be drastically reduced. For instance, we prove that minimum spanning tree can be certified with -bit certificates in n-node graphs, with just one interaction between the prover and the disprover, while it is known that certifying MST requires -bit certificates if only the prover can act. The improvement can even be exponential for some simple graph properties. For instance, it is known that certifying the existence of a nontrivial automorphism requires bits if only the prover can act. We show that there is a protocol with two interactions between the prover and the disprover enabling to certify nontrivial automorphism with -bit certificates. These results are achieved by defining and analysing a local hierarchy of decision which generalizes the classical notions of proof-labelling schemes and locally checkable proofs.
A dominating set D⊆V in a graph G=(V,E) is a subset of vertices such that every vertex in V belongs to D or has at least one neighbour in D. In this paper we deal with the problem of finding an approximation of the dominating set of minimum size, i.e., the approximation of the minimum dominating set problem (MDS) in a distributed setting. A distributed algorithm that runs in a constant number of rounds, independent of the size of the network, is called local. In research on distributed local algorithms it is commonly assumed that each vertex has an unique identifier. However, as was shown by Göös et al., for certain classes of graphs (for example, lift-closed bounded degree graphs) identifiers are unnecessary and only a port numbering is needed. We confirm that the same remains true for the MDS up to a constant factor in the class of planar graphs. Namely, we present a local deterministic 694-approximation algorithm for the MDS in planar graphs in a model with a port numbering only. Moreover, our algorithm uses only short messages, i.e., in each round each node can send only a O(log|V|)-bit message to each of its neighbours.
A central theme in distributed network algorithms concerns understanding and coping with the issue of locality. Yet despite considerable progress, research efforts in this direction have not yet resulted in a solid basis in the form of a fundamental computational complexity theory for locality. Inspired by sequential complexity theory, we focus on a complexity theory for distributed decision problems. In the context of locality, solving a decision problem requires the processors to independently inspect their local neighborhoods and then collectively decide whether a given global input instance belongs to some specified language.
We consider the standard LOCAL model of computation and define LD(t) (for local decision) as the class of decision problems that can be solved in t communication rounds. We first study the intriguing question of whether randomization helps in local distributed computing, and to what extent. Specifically, we define the corresponding randomized class BPLD(t,p,q), containing all languages for which there exists a randomized algorithm that runs in t rounds, accepts correct instances with probability at least p, and rejects incorrect ones with probability at least q. We show that p² + q = 1 is a threshold for the containment of LD(t) in BPLD(t,p,q). More precisely, we show that there exists a language that does not belong to LD(t) for any t=o(n) but does belong to BPLD(0,p,q) for any p,q ∈ (0,1) such that p² + q ≤ 1. On the other hand, we show that, restricted to hereditary languages, BPLD(t,p,q)=LD(O(t)), for any function t, and any p, q ∈ (0,1) such that p² + q > 1.
In addition, we investigate the impact of nondeterminism on local decision, and establish several structural results inspired by classical computational complexity theory. Specifically, we show that nondeterminism does help, but that this help is limited, as there exist languages that cannot be decided locally nondeterministically. Perhaps surprisingly, it turns out that it is the combination of randomization with nondeterminism that enables to decide all languages in constant time. Finally, we introduce the notion of local reduction, and establish a couple of completeness results.
We show that there is no deterministic local algorithm (constant-time
distributed graph algorithm) that finds a -approximation of a
minimum dominating set on planar graphs, for any positive constant .
In prior work, the best lower bound on the approximation ratio has been
; there is also an upper bound of 52.
In recent years growing interest in local distributed algorithms has widely been observed. This results from their high resistance to errors and damage, as well as from their good performance, which is independent of the size of the network. A local deterministic distributed algorithm finding an approximation of a Minimum Dominating Set in planar graphs has been presented by Lenzen et al., and they proved that the algorithm returns a 130-approximation of the Minimum Dominating Set. In this article we will show that the algorithm is two times more effective than was previously assumed, and we prove that the algorithm by Lenzen et al. outputs a 52-approximation to a Minimum Dominating Set. Therefore the gap between the lower bound and the approximation ratio of the best yet local deterministic distributed algorithm is reduced by half.
A dominating set is a subset of the nodes of a graph such that all nodes are in the set or adjacent to a node in the set. A minimum dominating set approximation is a dominating set that is not much larger than a dominating set with the fewest possible number of nodes. This article summarizes the state-of-the-art with respect to finding minimum dominating set approximations in distributed systems, where each node locally executes a protocol on its own, communicating with its neighbors in order to achieve a solution with good global properties. Moreover, we present a number of recent results for specific families of graphs in detail. A unit disk graph is given by an embedding of the nodes in the Euclidean plane, where two nodes are joined by an edge exactly if they are in distance at most one. For this family of graphs, we prove an asymptotically tight lower bound on the trade-off between time complexity and approximation ratio of deterministic algorithms. Next, we consider graphs of small arboricity, whose edge sets can be decomposed into a small number of forests. We give two algorithms, a randomized one excelling in its approximation ratio and a uniform deterministic one which is faster and simpler. Finally, we show that in planar graphs, which can be drawn in the Euclidean plane without intersecting edges, a constant approximation factor can be ensured within a constant number of communication rounds.
We give deterministic distributed algorithms that given δ> 0 find in a planar graph G, (1±δ)-approximations of a maximum independent set, a maximum matching, and a minimum dominating set. The algorithms run in O(log*|G|) rounds. In addition, we prove that no faster deterministic approximation is possible and show that if randomization is
allowed it is possible to beat the lower bound for deterministic algorithms.
A new paradigm for the design of self-stabilizing distributed algorithms, called local detection, is introduced. The essence of the paradigm is in defining a local condition based on the state of a processor and its immediate neighborhood such that the system is in a globally legal state if and only if the local condition is satisfied at all the nodes. In this work we also extend the model of self-stabilizing networks traditionally assuming memory failure to include the model of dynamic networks (assuming edge failures and recoveries). We apply the paradigm to the extended model which we call “dynamic self-stabilizing networks”. Without loss of generality, we present the results in the least restrictive shared memory model of read/write atomicity, to which end we construct basic information transfer primitives.Using local detection, we develop deterministic and randomized self-stabilizing algorithms that maintain a rooted spanning tree in a general network whose topology changes dynamically. The deterministic algorithm assumes unique identities while the randomized assumes an anonymous network. The algorithms use a constant number of memory words per edge in each node; and both the size of memory words and of messages is the number of bits necessary to represent a node identity (typically O(log n) bits where n is the size of the network). These algorithms provide for the easy construction of self-stabilizing protocols for numerous tasks: reset, routing, topology-update and self-stabilization transformers that automatically self-stabilize existing protocols for which local detection conditions can be defined.
A probabilistic C-embedding of a (guest) metric M into a collection of(host) metrics M'1, ..., M'k is a randomized mapping F of M intoone of the M'1, ..., M'k such that, for any two points p,q in theguest metric: The distance between F(p) and F(q) in any M'i is not smaller thanthe original distance between p and q. The expected distance between F(p) and F(q) in (random) M'i is notgreater than some constant C times the original distance, for C≥ 1. The constant C is called the distortion of the embedding. Low-distortion probabilistic embeddings enable reducing algorithmicproblems over "hard" guest metrics into "easy" host metrics.We show that every metric induced by a graph of bounded genus can beprobabilistically embedded into planar graphs, with constant distortion. The embedding can be computed efficiently, given a drawing of the graphon a genus-g surface.
We give ecien t deterministic distributed algorithms which given a graph G from a proper minor-closed family C nd an approxi- mation of a minimum dominating set in G and a minimum connected dominating set in G. The algorithms are deterministic and run in a poly- logarithmic number of rounds. The approximation accomplished diers from an optimal by a multiplicative factor of (1 + o(1)).
We consider asynchronous general topology dynamic networks of
identical nameless nodes with worst-case transient faults. Starting from
any faulty configuration, our protocols self-stabilize any computation
in time polynomial in the (unknown) network diameter. This version
sacrifices some diversity of tasks and efficiency for simplicity and
clarity of details. Appendix gives more efficient procedures in less
detail
The first self-stabilizing end-to-end communication protocol and
the most efficient known self-stabilizing network reset protocol are
introduced. A simple method of local checking and correction, by which
distributed protocols can be made self-stabilizing without the use of
unbounded counters, is used. The self-stabilization model distinguishes
between catastrophic faults that abstract arbitrary corruption of global
state, and other restricted kinds of anticipated faults. It is assumed
that after the execution starts there are no further catastrophic
faults, but the anticipated faults may continue to occur
We give time lower bounds for the distributed approximation of minimum vertex cover (MVC) and related problems such as minimum dominating set (MDS). In k communication rounds, MVC and MDS can only be approximated by factors# /k) and #d /k) for some constant c, where n and # denote the number of nodes and the largest degree in the graph. The number of rounds required in order to achieve a constant or even only a polylogarithmic approximation ratio is at log n/ log log n) and #nd #/ log log #). By a simple reduction, the latter lower bounds also hold for the construction of maximal matchings and maximal independent sets.
An arrangement of pseudocircles is a finite set of oriented closed Jordan curves each two of which cross each other in exactly two points. To describe the combinatorial structure of arrangements on closed orientable surfaces, in (Linhart, Ortner 2004) so-called *intersection schemes* were introduced. Building up on results about the latter, we first clarify the notion of embedding of an arrangement. Once this is done it is shown how the embeddability of an arrangement depends on the embeddability of its subarrangements. The main result presented is that an arrangement of pseudocircles can be embedded into the sphere if and only if all of its subarrangements of four pseudocircles are embeddable into the sphere as well.
Testability and local certification of monotone properties in minor-closed classes
- Esperet
Locally checkable proofs in distributed computing
- Göös
Trade-offs in distributed interactive proofs
- Crescenzi
Near-optimal distributed DFS in planar graphs
- Ghaffari