No full-text available
To read the full-text of this research,
you can request a copy directly from the authors.
A lower bound for constant-size local certification
ResearchGate has not been able to resolve any citations for this publication.
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.
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.
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.
We introduce a novel lower bound technique for distributed graph algorithms under bandwidth limitations. We define the notion of fooling views and exemplify its strength by proving two new lower bounds for triangle membership in the Congest(B)(B) model: Any 1-round algorithm requires B≥cΔlogn for a constant c>0.
If B=1B=1, even in constant-degree graphs any algorithm must take Ω(log∗n) rounds.
The implication of the former is the first proven separation between the Local and the Congest models for deterministic triangle membership. The latter result is the first non-trivial lower bound on the number of rounds required, even for triangle detection, under limited bandwidth. All previous known techniques are provably incapable of giving these bounds. We hope that our approach may pave the way for proving lower bounds for additional problems in various settings of distributed computing for which previous techniques do not suffice.
The problem of verifying a Minimum Spanning Tree (MST) was introduced by Tarjan in a sequential setting. Given a graph and
a tree that spans it, the algorithm is required to check whether this tree is an MST. This paper investigates the problem
in the distributed setting, where the input is given in a distributed manner, i.e., every node “knows” which of its own emanating
edges belong to the tree. Informally, the distributed MST verification problem is the following. Label the vertices of the
graph in such a way that for every node, given (its own state and label and) the labels of its neighbors only, the node can
detect whether these edges are indeed its MST edges. In this paper, we present such a verification scheme with a maximum label
size of O(log n log W), where n is the number of nodes and W is the largest weight of an edge. We also give a matching lower bound of Ω(log n log W) (as long as W > (log n)1+ε for some fixed ε>0). Both our bounds improve previously known bounds for the problem.
For the related problem of tree sensitivity also presented by Tarjan, our method yields rather efficient schemes for both
the distributed and the sequential settings.
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
A self stabilizing protocol for constructing a rooted spanning tree in an arbitrary asynchronous network of processors that communicate through shared memory is presented. The processors have unique identifiers but are otherwise identical. The network topology is assumed to be dynamic, that is, edges can join or leave the computation before it eventually stabilizes.
The algorithm is design uses a new paradigm in self stabilization. The idea is to ensure that if the system is not in a legal state (this is a global condition) then a local condition of some node will be violated. Thus the new could restart the algorithm.
The algorithm provides an underlying self-stabilization mechanism and can serve as a basic building block in the construction of self stabilizing protocols for several other applications such as: mutual-exclusion, snapshot, and reset.
The algorithm is memory efficient in that it requires only a linear size memory of words of size log n (the size of an identity) over the entire network. Each processor needs a constant number of words per incident link, thus the storage requirement is in the same order of magnitude as the size of the traditionally assumed message buffers size. The adversary may be permitted to initiate the values of the variables to any size. Still, in this case the additional memory used by the algorithm is the amount stated above.
Extensions of our algorithm to other models are also discussed.
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.
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
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.
A key concept in the theory of distributed computing is locality: if I am a node in the middle of a large graph, how far do I need to see in order to pick my own part of the solution? A modern, effective technique for studying such questions is called round elimination.
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.
Verifying that a network configuration satisfies a given boolean predicate is a fundamental problem in distributed computing. Many variations of this problem have been studied, for example, in the context of proof labeling schemes (), locally checkable proofs (), and non-deterministic local decision (). In all of these contexts, verification time is assumed to be constant. Korman et al. [16] presented a proof-labeling scheme for MST, with poly-logarithmic verification time, and logarithmic memory at each vertex.
Locally finding a solution to symmetry-breaking tasks such as
vertex-coloring, edge-coloring, maximal matching, maximal independent set,
etc., is a long-standing challenge in distributed network computing. More
recently, it has also become a challenge in the framework of centralized local
computation. We introduce conflict coloring as a general symmetry-breaking task
that includes all the aforementioned tasks as specific instantiations ---
conflict coloring includes all locally checkable labeling tasks from
[Naor\\&Stockmeyer, STOC 1993]. Conflict coloring is characterized by two
parameters l and d, where the former measures the amount of freedom given
to the nodes for selecting their colors, and the latter measures the number of
constraints which colors of adjacent nodes are subject to. We show that, in the
standard \LOCAL model for distributed network computing, if l/d \textgreater{}
\Delta, then conflict coloring can be solved in
\Otilde(\sqrt{\Delta})+\log^*n rounds in n-node graphs with maximum
degree~, where \Otilde ignores the polylog factors in . The
dependency in~n is optimal, as a consequence of the lower
bound by [Linial, SIAM J. Comp. 1992] for -coloring. An important
special case of our result is a significant improvement over the best known
algorithm for distributed -coloring due to [Barenboim, PODC 2015],
which required \Otilde(\Delta^{3/4})+\log^*n rounds. Improvements for other
variants of coloring, including -list-coloring,
-edge-coloring, T-coloring, etc., also follow from our general
result on conflict coloring. Likewise, in the framework of centralized local
computation algorithms (LCAs), our general result yields an LCA which requires
a smaller number of probes than the previously best known algorithm for
vertex-coloring, and works for a wide range of coloring problems.
It follows from the definition of silent self-stabilization, and from the definition of proof-labeling scheme, that if there exists a silent self-stabilizing algorithm using ℓ-bit registers for solving a task , then there exists a proof-labeling scheme for using registers of at most ℓ bits. The first result in this paper is the converse to this statement. We show that if there exists a proof-labeling scheme for a task , using ℓ-bit registers, then there exists a silent self-stabilizing algorithm using registers of at most O(ℓ + logn) bits for solving , where n is the number of processes in the system. Therefore, as far as memory space is concerned, the design of silent self-stabilizing algorithms essentially boils down to the design of compact proof-labeling schemes. The second result in this paper addresses time complexity. We show that, for every task with k-bits output size in n-node networks, there exists a silent self-stabilizing algorithm solving in O(n) rounds, using registers of O(n
2 + kn) bits. Therefore, as far as running time is concerned, every task has a silent self-stabilizing algorithm converging in a linear number of rounds.
Trade-offs in distributed interactive proofs
- Pierluigi Crescenzi
- Pierre Fraigniaud
- Ami Paz
What can be computed locally?
- Naor
Explicit space-time tradeoffs for proof labeling schemes in graphs with small separators
- Orr Fischer
- Rotem Oshman
- Dana Shamir
Testability and local certification of monotone properties in minor-closed classes
- Esperet
Locally checkable proofs in distributed computing
- Göös
Local conflict coloring revisited: linial for lists
- Maus
Trade-offs in distributed interactive proofs
- Crescenzi
Explicit space-time tradeoffs for proof labeling schemes in graphs with small separators
- Fischer