60,484 research outputs found
Streaming algorithms for language recognition problems
We study the complexity of the following problems in the streaming model.
Membership testing for \DLIN We show that every language in \DLIN\ can be
recognised by a randomized one-pass space algorithm with inverse
polynomial one-sided error, and by a deterministic p-pass space
algorithm. We show that these algorithms are optimal.
Membership testing for \LL For languages generated by \LL grammars
with a bound of on the number of nonterminals at any stage in the left-most
derivation, we show that membership can be tested by a randomized one-pass
space algorithm with inverse polynomial (in ) one-sided error.
Membership testing for \DCFL We show that randomized algorithms as efficient
as the ones described above for \DLIN\ and \LL(k) (which are subclasses of
\DCFL) cannot exist for all of \DCFL: there is a language in \VPL\ (a subclass
of \DCFL) for which any randomized p-pass algorithm with error bounded by
must use space.
Degree sequence problem We study the problem of determining, given a sequence
and a graph , whether the degree sequence of is
precisely . We give a randomized one-pass space
algorithm with inverse polynomial one-sided error probability. We show that our
algorithms are optimal.
Our randomized algorithms are based on the recent work of Magniez et al.
\cite{MMN09}; our lower bounds are obtained by considering related
communication complexity problems
Finite state verifiers with constant randomness
We give a new characterization of as the class of languages
whose members have certificates that can be verified with small error in
polynomial time by finite state machines that use a constant number of random
bits, as opposed to its conventional description in terms of deterministic
logarithmic-space verifiers. It turns out that allowing two-way interaction
with the prover does not change the class of verifiable languages, and that no
polynomially bounded amount of randomness is useful for constant-memory
computers when used as language recognizers, or public-coin verifiers. A
corollary of our main result is that the class of outcome problems
corresponding to O(log n)-space bounded games of incomplete information where
the universal player is allowed a constant number of moves equals NL.Comment: 17 pages. An improved versio
Semi-Streaming Algorithms for Annotated Graph Streams
Considerable effort has been devoted to the development of streaming
algorithms for analyzing massive graphs. Unfortunately, many results have been
negative, establishing that a wide variety of problems require
space to solve. One of the few bright spots has been the development of
semi-streaming algorithms for a handful of graph problems -- these algorithms
use space .
In the annotated data streaming model of Chakrabarti et al., a
computationally limited client wants to compute some property of a massive
input, but lacks the resources to store even a small fraction of the input, and
hence cannot perform the desired computation locally. The client therefore
accesses a powerful but untrusted service provider, who not only performs the
requested computation, but also proves that the answer is correct.
We put forth the notion of semi-streaming algorithms for annotated graph
streams (semi-streaming annotation schemes for short). These are protocols in
which both the client's space usage and the length of the proof are . We give evidence that semi-streaming annotation schemes
represent a substantially more robust solution concept than does the standard
semi-streaming model. On the positive side, we give semi-streaming annotation
schemes for two dynamic graph problems that are intractable in the standard
model: (exactly) counting triangles, and (exactly) computing maximum matchings.
The former scheme answers a question of Cormode. On the negative side, we
identify for the first time two natural graph problems (connectivity and
bipartiteness in a certain edge update model) that can be solved in the
standard semi-streaming model, but cannot be solved by annotation schemes of
"sub-semi-streaming" cost. That is, these problems are just as hard in the
annotations model as they are in the standard model.Comment: This update includes some additional discussion of the results
proven. The result on counting triangles was previously included in an ECCC
technical report by Chakrabarti et al. available at
http://eccc.hpi-web.de/report/2013/180/. That report has been superseded by
this manuscript, and the CCC 2015 paper "Verifiable Stream Computation and
Arthur-Merlin Communication" by Chakrabarti et a
On the state complexity of semi-quantum finite automata
Some of the most interesting and important results concerning quantum finite
automata are those showing that they can recognize certain languages with
(much) less resources than corresponding classical finite automata
\cite{Amb98,Amb09,AmYa11,Ber05,Fre09,Mer00,Mer01,Mer02,Yak10,ZhgQiu112,Zhg12}.
This paper shows three results of such a type that are stronger in some sense
than other ones because (a) they deal with models of quantum automata with very
little quantumness (so-called semi-quantum one- and two-way automata with one
qubit memory only); (b) differences, even comparing with probabilistic
classical automata, are bigger than expected; (c) a trade-off between the
number of classical and quantum basis states needed is demonstrated in one case
and (d) languages (or the promise problem) used to show main results are very
simple and often explored ones in automata theory or in communication
complexity, with seemingly little structure that could be utilized.Comment: 19 pages. We improve (make stronger) the results in section
MPC for MPC: Secure Computation on a Massively Parallel Computing Architecture
Massively Parallel Computation (MPC) is a model of computation widely believed to best capture realistic parallel computing architectures such as large-scale MapReduce and Hadoop clusters. Motivated by the fact that many data analytics tasks performed on these platforms involve sensitive user data, we initiate the theoretical exploration of how to leverage MPC architectures to enable efficient, privacy-preserving computation over massive data. Clearly if a computation task does not lend itself to an efficient implementation on MPC even without security, then we cannot hope to compute it efficiently on MPC with security. We show, on the other hand, that any task that can be efficiently computed on MPC can also be securely computed with comparable efficiency. Specifically, we show the following results:
- any MPC algorithm can be compiled to a communication-oblivious counterpart while asymptotically preserving its round and space complexity, where communication-obliviousness ensures that any network intermediary observing the communication patterns learn no information about the secret inputs;
- assuming the existence of Fully Homomorphic Encryption with a suitable notion of compactness and other standard cryptographic assumptions, any MPC algorithm can be compiled to a secure counterpart that defends against an adversary who controls not only intermediate network routers but additionally up to 1/3 - ? fraction of machines (for an arbitrarily small constant ?) - moreover, this compilation preserves the round complexity tightly, and preserves the space complexity upto a multiplicative security parameter related blowup.
As an initial exploration of this important direction, our work suggests new definitions and proposes novel protocols that blend algorithmic and cryptographic techniques
State succinctness of two-way finite automata with quantum and classical states
{\it Two-way quantum automata with quantum and classical states} (2QCFA) were
introduced by Ambainis and Watrous in 2002. In this paper we study state
succinctness of 2QCFA.
For any and any , we show that:
{enumerate} there is a promise problem which can be solved by a
2QCFA with one-sided error in a polynomial expected running time
with a constant number (that depends neither on nor on ) of
quantum states and classical states,
whereas the sizes of the corresponding {\it deterministic finite automata}
(DFA), {\it two-way nondeterministic finite automata} (2NFA) and polynomial
expected running time {\it two-way probabilistic finite automata} (2PFA) are at
least , , and , respectively; there
exists a language over the alphabet
which can be recognized by a 2QCFA with one-sided error
in an exponential expected running time with a constant number of
quantum states and classical states,
whereas the sizes of the corresponding DFA, 2NFA and polynomial expected
running time 2PFA are at least , , and ,
respectively; {enumerate} where is a constant.Comment: 26pages, comments and suggestions are welcom
Silent MST approximation for tiny memory
In network distributed computing, minimum spanning tree (MST) is one of the
key problems, and silent self-stabilization one of the most demanding
fault-tolerance properties. For this problem and this model, a polynomial-time
algorithm with memory is known for the state model. This is
memory optimal for weights in the classic range (where
is the size of the network). In this paper, we go below this
memory, using approximation and parametrized complexity.
More specifically, our contributions are two-fold. We introduce a second
parameter~, which is the space needed to encode a weight, and we design a
silent polynomial-time self-stabilizing algorithm, with space . In turn, this allows us to get an approximation algorithm for the problem,
with a trade-off between the approximation ratio of the solution and the space
used. For polynomial weights, this trade-off goes smoothly from memory for an -approximation, to memory for exact solutions,
with for example memory for a 2-approximation
Streaming Verification of Graph Properties
Streaming interactive proofs (SIPs) are a framework for outsourced
computation. A computationally limited streaming client (the verifier) hands
over a large data set to an untrusted server (the prover) in the cloud and the
two parties run a protocol to confirm the correctness of result with high
probability. SIPs are particularly interesting for problems that are hard to
solve (or even approximate) well in a streaming setting. The most notable of
these problems is finding maximum matchings, which has received intense
interest in recent years but has strong lower bounds even for constant factor
approximations.
In this paper, we present efficient streaming interactive proofs that can
verify maximum matchings exactly. Our results cover all flavors of matchings
(bipartite/non-bipartite and weighted). In addition, we also present streaming
verifiers for approximate metric TSP. In particular, these are the first
efficient results for weighted matchings and for metric TSP in any streaming
verification model.Comment: 26 pages, 2 figure, 1 tabl
- …