Constant Number Of Rounds Research Articles

Constant-Round YOSO MPC Without Setup

YOSO MPC (Gentry et al., Crypto 2021) is a new MPC framework where each participant can speak at most once. This models an adaptive adversary’s ability to watch the network and corrupt or destroy parties it deems significant based on their communication. By using private channels to anonymous receivers (e.g. by encrypting to a public key whose owner is unknown), the communication complexity of YOSO MPC can scale sublinearly with the total number N of available parties, even when the adversary’s corruption threshold is linear in N (e.g. just under N/2). It was previously an open problem whether YOSO MPC can achieve guaranteed output delivery in a constant number of rounds without relying on trusted setup. In this work, we show that this can indeed be accomplished. We demonstrate three different approaches: the first two (which we call YaOSO and YOSO-GLS) use two and three rounds of communication, respectively. Our third approach (which we call YOSO-LHSS) uses O(d) rounds, where d is the multiplicative depth of the circuit being evaluated; however, it can be used to bootstrap any constant-round YOSO protocol that requires setup, by generating that setup within YOSO-LHSS. Though YOSO-LHSS requires more rounds than our first two approaches, it may be more practical, since the zero knowledge proofs it employs are more efficient to instantiate. As a contribution of independent interest, we introduce a verifiable state propagation UC functionality, which allows parties to send private message which are verifiably derived in the “correct” way (according to the protocol in question) to anonymous receivers. This is a natural functionality to build YOSO protocols on top of.

Distributed domination on sparse graph classes

We show that the dominating set problem admits a constant factor approximation in a constant number of rounds in the LOCAL model of distributed computing on graph classes with bounded expansion. This generalizes a result of Czygrinow et al. for graphs with excluded topological minors to very general classes of uniformly sparse graphs. We demonstrate how our general algorithm can be modified and fine-tuned to compute an (11+ɛ)-approximation (for any ɛ>0) of a minimum dominating set on planar graphs. This improves on the previously best known approximation factor of 52 on planar graphs, which was achieved by an elegant and simple algorithm of Lenzen et al.

Zero-Knowledge Proofs for Classical Planning Problems

In classical planning, the aim is to find a sequence of deterministic actions leading from the initial to a goal state. In this work, we consider the scenario where a party who knows the solution to a planning task, called the prover, wants to convince a second party, the verifier, that it has the solution without revealing any information about the solution itself. This is relevant in domains where privacy is important, for example when plans contain sensitive information or when the solution should not be revealed upfront. We achieve this by introducing a zero-knowledge protocol for plan existence. By restricting ourselves to tasks with polynomially-bounded plan length, we are able to construct a protocol that can be run efficiently by both the prover and verifier. The resulting protocol does not rely on any reduction, has a constant number of rounds, and runs in time polynomial in the size of the task.

Distributed distance domination in graphs with no K2,t-minor

We prove that a simple distributed algorithm finds a constant approximation of an optimal distance-k dominating set in graphs with no K2,t-minor. The algorithm runs in a constant number of rounds. We further show how this procedure can be used to give a distributed algorithm which given ϵ>0 and k,t∈Z+ finds in a graph G=(V,E) with no K2,t-minor a distance-k dominating set of size at most (1+ϵ) of the optimum. The algorithm runs in O(log⁎⁡|V|) rounds in the Local model. In particular, both algorithms work in outerplanar graphs.

Distributed distance-r covering problems on sparse high-girth graphs

We prove that the distance-r dominating set, distance-r connected dominating set, distance-r vertex cover, and distance-r connected vertex cover problems admit constant factor approximations in the CONGEST model of distributed computing in a constant number of rounds on classes of sparse high-girth graphs. In this paper, sparse means bounded expansion, and high-girth means girth at least 4r+2. Our algorithm is quite simple; however, the proof of its approximation guarantee is non-trivial. To complement the algorithmic results, we show tightness of our approximation by providing a loosely matching lower bound on rings.Our result is the first to show the existence of constant-factor approximations in a constant number of rounds in non-trivial classes of graphs for distance-r covering problems.

Parallel graph algorithms in constant adaptive rounds

We study fundamental graph problems such as graph connectivity, minimum spanning forest (MSF), and approximate maximum (weight) matching in a distributed setting. In particular, we focus on the Adaptive Massively Parallel Computation (AMPC) model, which is a theoretical model that captures MapReduce-like computation augmented with a distributed hash table. We show the first AMPC algorithms for all of the studied problems that run in a constant number of rounds and use only O ( n ϵ ) space per machine, where 0 < ϵ < 1. Our results improve both upon the previous results in the AMPC model, as well as the best-known results in the MPC model, which is the theoretical model underpinning many popular distributed computation frameworks, such as MapReduce, Hadoop, Beam, Pregel and Giraph. Finally, we provide an empirical comparison of the algorithms in the MPC and AMPC models in a fault-tolerant distributed computation environment. We empirically evaluate our algorithms on a set of large real-world graphs and show that our AMPC algorithms can achieve improvements in both running time and round-complexity over optimized MPC baselines.

Distributed reconfiguration of maximal independent sets

We investigate a distributed maximal independent set reconfiguration problem, in which there are two MIS for which every node is given its membership status, and the nodes need to communicate with their neighbors to find a reconfiguration schedule from the first MIS to the second. We forbid two neighbors to change their membership status at the same step. We provide efficient solutions when the intermediate sets are only required to be independent and 4-dominating, which is almost always possible. Consequently, our goal is to pin down the tradeoff between the possible length of the schedule and the number of communication rounds. We prove that a constant length schedule can be found in O(MIS+R32) rounds. For bounded degree graphs, this is O(log⁎⁡n) rounds and we show that it is necessary. On the other extreme, we show that with a constant number of rounds we can find a linear length schedule.

Local approximation of the Maximum Cut in regular graphs

This paper is devoted to the distributed complexity of finding an approximation of the maximum cut (MaxCut) in graphs. A classical algorithm consists in letting each vertex choose its side of the cut uniformly at random. This does not require any communication and achieves an approximation ratio of at least 12 in expectation. When the graph is d-regular and triangle-free, a slightly better approximation ratio can be achieved with a randomized algorithm running in a single round. Here, we investigate the round complexity of deterministic distributed algorithms for MaxCut in regular graphs. We first prove that if G is d-regular, with d even and fixed, no deterministic algorithm running in a constant number of rounds can achieve a constant approximation ratio. We then give a simple one-round deterministic algorithm achieving an approximation ratio of 1d for d-regular graphs when d is odd. We show that this is best possible in several ways, and in particular no deterministic algorithm with approximation ratio 1d+ϵ (with ϵ>0) can run in a constant number of rounds. We also prove results of a similar flavor for the MaxDiCut problem in regular oriented graphs, where we want to maximize the number of arcs oriented from the left part to the right part of the cut.

On inequalities with bounded coefficients and pitch for the min knapsack polytope

The min knapsack problem appears as a major component in the structure of capacitated covering problems. Its polyhedral relaxations have been extensively studied, leading to strong relaxations for networking, scheduling and facility location problems.A valid inequality αTx≥α0 with α≥0 for a min knapsack instance is said to have pitch ≤π (π a positive integer) if the π smallest strictly positive αj sum to at least α0. An inequality with coefficients and right-hand side in {0,1,…,π} has pitch ≤π. The notion of pitch has been used for measuring the complexity of valid inequalities for the min knapsack polytope. Separating inequalities of pitch-1 is already NP-Hard. In this paper, we show an algorithm for efficiently separating inequalities with coefficients in {0,1,…,π} for any fixed π up to an arbitrarily small additive error. As a special case, this allows for approximate separation of inequalities with pitch at most 2. We moreover investigate the integrality gap of minimum knapsack instances when bounded pitch inequalities (possibly in conjunction with other inequalities) are added. Among other results, we show that the CG closure of minimum knapsack has unbounded integrality gap even after a constant number of rounds.

Distributed approximation algorithms for k-dominating set in graphs of bounded genus and linklessly embeddable graphs

A k-dominating set in a graph G=(V,E) is a set U⊆V such that every vertex of G is either in U or has at least k neighbors in U. In this paper we give simple distributed approximation algorithms in the standard Local model of computations for the minimum k-dominating set problem for k≥2 in graphs with no K3,h-minor for some h∈Z+ and graphs with no K4,4-minor. In particular, this gives fast distributed approximations for graphs of bounded genus and linklessly embeddable graphs. The algorithms give a constant approximation ratio and run in a constant number of rounds. In addition, we will give a (1+ϵ)-approximation for an arbitrary fixed ϵ>0 which runs in O(log⁎⁡n) rounds where n is the order of a graph.

Highly Efficient and Re-executable Private Function Evaluation with Linear Complexity

Private function evaluation aims to securely compute a function f(x_1,…, x_n) without leaking any information other than what is revealed by the output, where f is a private input of one of the parties (say Party1) and x_i is a private input of the i-th party Party_i. In this work, we propose a novel and secure two-party private function evaluation (2PFE) scheme based on the DDH assumption. Our scheme introduces a reusability feature that significantly improves the state-of-the-art. Accordingly, our scheme has two variants, one is utilized in the initial execution of the function f, and the other is utilized in its subsequent evaluations. To the best of our knowledge, this is the first and most efficient 2PFE scheme that enjoys a reusability feature. Our protocols achieve linear communication and computation complexities and a constant number of rounds which is at most three.

Distributed Detection of Cycles

Distributed property testing in networks has been introduced by Brakerski and Patt-Shamir [6], with the objective of detecting the presence of large dense sub-networks in a distributed manner. Recently, Censor-Hillel et al. [7] have revisited this notion and formalized it in a broader context. In particular, they have shown how to detect 3-cycles in a constant number of rounds by a distributed algorithm. In a follow-up work, Fraigniaud et al. [21] have shown how to detect 4-cycles in a constant number of rounds as well. However, the techniques in these latter works were shown not to generalize to larger cycles C k with k ≥ 5. In this article, we completely settle the problem of cycle detection by establishing the following result: For every k ≥ 3, there exists a distributed property testing algorithm for C k -freeness, performing in a constant number of rounds. All these results hold in the classical congest model for distributed network computing. Our algorithm is 1-sided error. Its round-complexity is O (1ϵ) where ϵ ∈ (0,1) is the property-testing parameter measuring the gap between legal and illegal instances.

Finite-State Map-Reduce Computation and Relational Algebra Queries

We introduce three formal models of distributed systems for query evaluation on massive databases: Distributed Streaming with Register Automata (DSAs), Distributed Streaming with Register Transducers (DSTs), and Distributed Streaming with Register Transducers and Joins (DSTJs). These models are based on the map-reduce paradigm where the input is transformed into a dataset of key-value pairs, and on each key a local computation is performed on the values associated with that key resulting in another set of key-value pairs. Computation proceeds in a constant number of rounds, where the result of the last round is the input to the next round, and transformation of key-value pairs is required to be generic. The difference between the three models is in the local computation part. In DSAs it is limited to making one pass over its input using a register automaton, while in DSTs it can make two passes: in the first pass it uses a finite state automaton and in the second it uses a register transducer. The third model DSTJs is an extension of DSTs, where local computations are capable of constructing the Cartesian product of two sets. We obtain the following results: (1) DSAs can evaluate first-order queries over bounded degree databases; (2) DSTs can evaluate semijoin algebra queries over arbitrary databases; (3) DSTJs can evaluate the whole relational algebra over arbitrary databases; (4) DSTJs are strictly stronger than DSTs, which in turn are strictly stronger than DSAs; (5) within DSAs, DSTs, and DSTJs, there is a strict hierarchy w.r.t. the number of rounds.

Lift-and-Project Methods for Set Cover and Knapsack

We study the applicability of lift-and-project methods to the Set Cover and Knapsack problems. Inspired by recent work of Karlin et al. (IPCO 2011), who examined this connection for Knapsack, we consider the applicability and limitations of these methods for Set Cover, as well as extend the existing results for Knapsack. For the Set Cover problem, Cygan et al. (IPL 2009) gave sub-exponential-time approximation algorithms with approximation ratios better than $$\ln n$$ . We present a very simple combinatorial algorithm which has nearly the same time-approximation tradeoff as the algorithm of Cygan et al. We then adapt this to an LP-based algorithm using the LP hierarchy of Lovasz and Schrijver. However, our approach involves the trick of “lifting the objective function”. We show that this trick is essential, by demonstrating an integrality gap of $$(1-\varepsilon )\ln n$$ at level $$\Omega (n)$$ of the stronger LP hierarchy of Sherali and Adams (when the objective function is not lifted). Finally, we show that the SDP hierarchy of Lovasz and Schrijver ( $$\mathrm{LS}_+$$ ) reduces the integrality gap for Knapsack to $$(1+\varepsilon )$$ at level O(1). This stands in contrast to Set Cover (where the work of Aleknovich et al. (STOC 2005) rules out any improvement using $$\mathrm{LS}_+$$ ), and extends the work of Karlin et al., who demonstrated such an improvement only for the more powerful SDP hierarchy of Lasserre. Our $$\mathrm{LS}_+$$ -based rounding and analysis are quite different from theirs (in particular, not relying on the decomposition theorem they prove for the Lasserre hierarchy), and to the best of our knowledge represents the first explicit demonstration of such a reduction in the integrality gap of $$\mathrm{LS}_+$$ relaxations after a constant number of rounds.

Computing large independent sets in a single round

Independent sets play a central role in distributed algorithmics. We examine here the minimal requirements for computing non-trivial independent sets. In particular, we focus on algorithms that operate in a single communication round. A classic result of Linial shows that a constant number of rounds does not suffice to compute a maximal independent set. We are therefore interested in the size of the solution that can be computed, especially in comparison to the optimal. Our main result is a randomized one-round algorithm that achieves poly-logarithmic approximation on graphs of polynomially bounded-independence. Specifically, we show that the algorithm achieves the Caro-Wei bound (an extension of the Turán bound for independent sets) in general graphs up to a constant factor, and that the Caro-Wei bound yields a poly-logarithmic approximation on bounded-independence graphs. The algorithm uses only a single bit message and operates in a beeping model, where a node receives only the disjunction of the bits transmitted by its neighbors. We give limitation results that show that these are the minimal requirements for obtaining non-trivial solutions. In particular, a sublinear approximation cannot be obtained in a single round on general graphs, nor when nodes cannot both transmit and receive messages. We also show that our analysis of the Caro-Wei bound on polynomially bounded-independence graphs is tight, and that the poly-logarithmic approximation factor does not extend to mathrm {O}(1)-claw free graphs.

Leader Election in Sparse Dynamic Networks with Churn

AbstractWe investigate the problem of electing a leader in a sparse but well-connected synchronous dynamic network in which up to a fraction of the nodes chosen adversarially can leave/join the network per time step. At this churn rate, all nodes in the network can be replaced by new nodes in a constant number of rounds. Moreover, the adversary can shield a fraction of the nodes (which may include the leader) by repeatedly churning their neighborhood and, thus, hindering, their communication with the rest of the network. However, empirical studies in peer-to-peer networks have shown that a significant fraction of the nodes are usually stable and well connected. It is, therefore, natural to take advantage of such stability to establish a leader that can maintain good communication with the rest of the nodes. Because the dynamics could change eventually, it is also essential to reelect a new leader whenever the current leader either has left the network or is not well-connected with rest of the nodes. In su...

A local approximation algorithm for minimum dominating set problem in anonymous planar networks

A dominating set $$D \subseteq V$$D⊆V in a graph $$G=(V,E)$$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 Goos 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|})$$O(log|V|)-bit message to each of its neighbours.

Achieving fairness by sequential equilibrium in rational two‐party computation under incomplete information

AbstractFairness in secure two‐party computation ensures that either both of the communicating parties learn the output of some pre‐defined function or none of them does. Rational two‐party computation is an extension of two‐party computation that incorporates game theory into conventional two‐party (cryptographic) computation protocols for achieving fairness. From the standpoint of game theory, the strategies are designed for achieving equilibrium resulting in attaining fairness in rational two‐party computation protocols. Groce and Katz (Eurocrypt 2012) achieved fairness by computational Nash equilibrium under complete information. In this paper, protocols are considered in more practical scenarios of incomplete information, where fairness is achieved by sequential equilibrium. Our protocol has constant number of rounds as Groce and Katz do while achieving a stronger sequential equilibrium which also implies the computational Nash equilibrium. Copyright © 2015 John Wiley & Sons, Ltd.

Efficient Cloud Storage Management UsingDHT Mechanism

Cloud computing enables a wide range of users to access distributed over the Internet. During the centralized cloud management to satisfy user needs and data backup becomes a critical concern. The proposed method solves this issue by focuses on the following factors, user provisioning cost, security, load balancing and redundancy .To carry out this process perform local and global de-duplication process, chunking of data, hash function, load balancing. An intelligent data chunking and Hash functions is performed to chunks of data. Load balancing function is used to balance the load while storing the files into the resources of cloud. Propose a fully distributed scheme which works in a constant number of rounds and achieves optimal balance with high probability. The optimal centralized algorithm is used for generating the migrations in cloud storage. Perform experiments to demonstrate that proposed scheme can significantly higher efficiency over the state-of-the-art methods.

Feasibility of Polynomial-Time Randomized Gathering for Oblivious Mobile Robots

We consider the problem of gathering n anonymous and oblivious mobile robots, which requires that all robots meet in finite time at a nonpredefined point. While the gathering problem cannot be solved deterministically without assuming any additional capabilities for the robots, randomized approaches easily allow it to be solvable. However, the randomized solutions currently known have a time complexity that is exponential in n with no additional assumption. This fact yields the following two questions: Is it possible to construct a randomized gathering algorithm with polynomial expected time? If it is not possible, what is the minimal additional assumption necessary to obtain such an algorithm? In this paper, we address these questions from the aspect of multiplicity-detection capabilities. We newly introduce two weaker variants of multiplicity detection, called local-strong and local-weak multiplicity, and investigate whether those capabilities permit a gathering algorithm with polynomial expected time or not. The contribution of this paper is to show that any algorithm only assuming local-weak multiplicity detection takes exponential number of rounds in expectation. On the other hand, we can obtain a constant-round gathering algorithm using local-strong multiplicity detection. These results imply that the two models of multiplicity detection are significantly different in terms of their computational power. Interestingly, these differences disappear if we take one more assumption that all robots are scattered (i.e., no two robots stay at the same location) initially. We can obtain a gathering algorithm that takes a constant number of rounds in expectation, assuming local-weak multiplicity detection and scattered initial configurations.