108 research outputs found
Multi-Party Protocols, Information Complexity and Privacy
We introduce the new measure of Public Information Complexity (PIC), as a tool for the study of multi-party computation protocols, and of quantities such as their communication complexity, or the amount of randomness they require in the context of information-theoretic private computations. We are able to use this measure directly in the natural asynchronous message-passing peer-to-peer model and show a number of interesting properties and applications of our new notion:
the Public Information Complexity is a lower bound on the Communication Complexity and an upper bound on the Information Complexity; the difference between the Public Information Complexity and the Information Complexity provides a lower bound on the amount of randomness used in a protocol; any communication protocol can be compressed to its Public Information Cost; an explicit calculation of the zero-error Public Information Complexity of the k-party, n-bit Parity function, where a player outputs the bit-wise parity of the inputs. The latter result establishes that the amount of randomness needed for a private protocol that computes this function is Omega(n)
Fine-Grained Reductions and Quantum Speedups for Dynamic Programming
This paper points at a connection between certain (classical) fine-grained reductions and the question: Do quantum algorithms offer an advantage for problems whose (classical) best solution is via dynamic programming?
A remarkable recent result of Ambainis et al. [SODA 2019] indicates that the answer is positive for some fundamental problems such as Set-Cover and Travelling Salesman. They design a quantum O^*(1.728^n) time algorithm whereas the dynamic programming O^*(2^n) time algorithms are conjectured to be classically optimal. In this paper, fine-grained reductions are extracted from their algorithms giving the first lower bounds for problems in P that are based on the intriguing Set-Cover Conjecture (SeCoCo) of Cygan et al. [CCC 2010].
In particular, the SeCoCo implies:
- a super-linear Omega(n^{1.08}) lower bound for 3-SUM on n integers,
- an Omega(n^{k/(c_k)-epsilon}) lower bound for k-SUM on n integers and k-Clique on n-node graphs, for any integer k >= 3, where c_k <= log_2{k}+1.4427.
While far from being tight, these lower bounds are significantly stronger than what is known to follow from the Strong Exponential Time Hypothesis (SETH); the well-known n^{Omega(k)} ETH-based lower bounds for k-Clique and k-SUM are vacuous when k is constant.
Going in the opposite direction, this paper observes that some "sequential" problems with previously known fine-grained reductions to a "parallelizable" core also enjoy quantum speedups over their classical dynamic programming solutions. Examples include RNA Folding and Least-Weight Subsequence
Robust Sparsification for Matroid Intersection with Applications
Matroid intersection is a classical optimization problem where, given two
matroids over the same ground set, the goal is to find the largest common
independent set. In this paper, we show that there exists a certain
"sparsifer": a subset of elements, of size ,
where denotes the optimal solution, that is guaranteed to contain a
approximation, while guaranteeing certain robustness
properties. We call such a small subset a Density Constrained Subset (DCS),
which is inspired by the Edge-Degree Constrained Subgraph (EDCS) [Bernstein and
Stein, 2015], originally designed for the maximum cardinality matching problem
in a graph. Our proof is constructive and hinges on a greedy decomposition of
matroids, which we call the density-based decomposition. We show that this
sparsifier has certain robustness properties that can be used in one-way
communication and random-order streaming models
Priority Downward Closures
When a system sends messages through a lossy channel, then the language
encoding all sequences of messages can be abstracted by its downward closure,
i.e. the set of all (not necessarily contiguous) subwords. This is useful
because even if the system has infinitely many states, its downward closure is
a regular language. However, if the channel has congestion control based on
priorities assigned to the messages, then we need a finer abstraction: The
downward closure with respect to the priority embedding. As for subword-based
downward closures, one can also show that these priority downward closures are
always regular.
While computing finite automata for the subword-based downward closure is
well understood, nothing is known in the case of priorities. We initiate the
study of this problem and provide algorithms to compute priority downward
closures for regular languages, one-counter languages, and context-free
languages.Comment: full version of paper accepted at CONCUR'2
The Complexity of the Diagonal Problem for Recursion Schemes
We consider nondeterministic higher-order recursion schemes as recognizers of languages of finite words or finite trees. We establish the complexity of the diagonal problem for schemes: given a set of letters A and a scheme G, is it the case that for every number n the scheme accepts a word (a tree) in which every letter from A appears at least n times. We prove that this problem is (m-1)-EXPTIME-complete for word-recognizing schemes of order m, and m-EXPTIME-complete for tree-recognizing schemes of order m
Hardness of Computing and Approximating Predicates and Functions with Leaderless Population Protocols
Population protocols are a distributed computing model appropriate for describing massive numbers of agents with very limited computational power (finite automata in this paper), such as sensor networks or programmable chemical reaction networks in synthetic biology. A population protocol is said to require a leader if every valid initial configuration contains a single agent in a special "leader" state that helps to coordinate the computation. Although the class of predicates and functions computable with probability 1 (stable computation) is the same whether a leader is required or not (semilinear functions and predicates), it is not known whether a leader is necessary for fast computation. Due to the large number of agents n (synthetic molecular systems routinely have trillions of molecules), efficient population protocols are generally defined as those computing in polylogarithmic in n (parallel) time. We consider population protocols that start in leaderless initial configurations, and the computation is regarded finished when the population protocol reaches a configuration from which a different output is no longer reachable.
In this setting we show that a wide class of functions and predicates computable by population protocols are not efficiently computable (they require at least linear time), nor are some linear functions even efficiently approximable. It requires at least linear time for a population protocol even to approximate division by a constant or subtraction (or any linear function with a coefficient outside of N), in the sense that for sufficiently small gamma > 0, the output of a sublinear time protocol can stabilize outside the interval f(m) (1 +/- gamma) on infinitely many inputs m. In a complementary positive result, we show that with a sufficiently large value of gamma, a population protocol can approximate any linear f with nonnegative rational coefficients, within approximation factor gamma, in O(log n) time. We also show that it requires linear time to exactly compute a wide range of semilinear functions (e.g., f(m)=m if m is even and 2m if m is odd) and predicates (e.g., parity, equality)
When Algorithms for Maximal Independent Set and Maximal Matching Run in Sublinear Time
Maximal independent set (MIS), maximal matching (MM), and (Delta+1)-(vertex) coloring in graphs of maximum degree Delta are among the most prominent algorithmic graph theory problems. They are all solvable by a simple linear-time greedy algorithm and up until very recently this constituted the state-of-the-art. In SODA 2019, Assadi, Chen, and Khanna gave a randomized algorithm for (Delta+1)-coloring that runs in O~(n sqrt{n}) time, which even for moderately dense graphs is sublinear in the input size. The work of Assadi et al. however contained a spoiler for MIS and MM: neither problems provably admits a sublinear-time algorithm in general graphs. In this work, we dig deeper into the possibility of achieving sublinear-time algorithms for MIS and MM.
The neighborhood independence number of a graph G, denoted by beta(G), is the size of the largest independent set in the neighborhood of any vertex. We identify beta(G) as the "right" parameter to measure the runtime of MIS and MM algorithms: Although graphs of bounded neighborhood independence may be very dense (clique is one example), we prove that carefully chosen variants of greedy algorithms for MIS and MM run in O(n beta(G)) and O(n log{n} * beta(G)) time respectively on any n-vertex graph G. We complement this positive result by observing that a simple extension of the lower bound of Assadi et al. implies that Omega(n beta(G)) time is also necessary for any algorithm to either problem for all values of beta(G) from 1 to Theta(n). We note that our algorithm for MIS is deterministic while for MM we use randomization which we prove is unavoidable: any deterministic algorithm for MM requires Omega(n^2) time even for beta(G) = 2.
Graphs with bounded neighborhood independence, already for constant beta = beta(G), constitute a rich family of possibly dense graphs, including line graphs, proper interval graphs, unit-disk graphs, claw-free graphs, and graphs of bounded growth. Our results suggest that even though MIS and MM do not admit sublinear-time algorithms in general graphs, one can still solve both problems in sublinear time for a wide range of beta(G) << n.
Finally, by observing that the lower bound of Omega(n sqrt{n}) time for (Delta+1)-coloring due to Assadi et al. applies to graphs of (small) constant neighborhood independence, we unveil an intriguing separation between the time complexity of MIS and MM, and that of (Delta+1)-coloring: while the time complexity of MIS and MM is strictly higher than that of (Delta+1) coloring in general graphs, the exact opposite relation holds for graphs with small neighborhood independence
Recursion Schemes and the WMSO+U Logic
We study the weak MSO logic extended by the unbounding quantifier (WMSO+U), expressing the fact that there exist arbitrarily large finite sets satisfying a given property. We prove that it is decidable whether the tree generated by a given higher-order recursion scheme satisfies a given sentence of WMSO+U
New Extremal Bounds for Reachability and Strong-Connectivity Preservers Under Failures
In this paper, we consider the question of computing sparse subgraphs for any
input directed graph on vertices and edges, that preserves
reachability and/or strong connectivity structures.
We show bound on a
subgraph that is an -fault-tolerant reachability preserver for a given
vertex-pair set , i.e., it preserves reachability
between any pair of vertices in under single edge (or vertex)
failure. Our result is a significant improvement over the previous best bound obtained as a corollary of single-source reachability
preserver construction. We prove our upper bound by exploiting the special
structure of single fault-tolerant reachability preserver for any pair, and
then considering the interaction among such structures for different pairs.
In the lower bound side, we show that a 2-fault-tolerant reachability
preserver for a vertex-pair set of size
, for even any arbitrarily small , requires at
least edges. This refutes the existence of
linear-sized dual fault-tolerant preservers for reachability for any polynomial
sized vertex-pair set.
We also present the first sub-quadratic bound of at most size, for strong-connectivity preservers of directed graphs under
failures. To the best of our knowledge no non-trivial bound for this
problem was known before, for a general . We get our result by adopting the
color-coding technique of Alon, Yuster, and Zwick [JACM'95]
- …