Time filter

Source Type

Amsterdam-Zuidoost, Netherlands

Cascudo I.,CWI Amsterdam | Cramer R.,Leiden University | Xing C.,Nanyang Technological University
Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics) | Year: 2011

An (n,t,d,n-t)-arithmetic secret sharing scheme (with uniformity) for double-struck Fqk over double-struck Fq is an double-struck Fq-linear secret sharing scheme where the secret is selected from double-struck Fqk and each of the n shares is an element of double-struck Fq. Moreover, there is t-privacy (in addition, any t shares are uniformly random in double-struck Fq t) and, if one considers the d-fold "component-wise" product of any d sharings, then the d-fold component-wise product of the d respective secrets is (n - t)-wise uniquely determined by it. Such schemes are a fundamental primitive in information-theoretically secure multi-party computation. Perhaps counter-intuitively, secure multi-party computation is a very powerful primitive for communication-efficient two-party cryptography, as shown recently in a series of surprising results from 2007 on. Moreover, the existence of asymptotically good arithmetic secret sharing schemes plays a crucial role in their communication-efficiency: for each d ≥ 2, if A(q) > 2d, where A(q) is Ihara's constant, then there exists an infinite family of such schemes over double-struck Fq such that n is unbounded, k = Ω(n) and t = Ω(n), as follows from a result at CRYPTO'06. Our main contribution is a novel paradigm for constructing asymptotically good arithmetic secret sharing schemes from towers of algebraic function fields. It is based on a new limit that, for a tower with a given Ihara limit and given positive integer ℓ, gives information on the cardinality of the ℓ-torsion sub-groups of the associated degree-zero divisor class groups and that we believe is of independent interest. As an application of the bounds we obtain, we relax the condition A(q) > 2d from the CRYPTO'06 result substantially in terms of our torsion-limit. As a consequence, this result now holds over nearly all finite fields double-struck Fq. For example, if d = 2, it is sufficient that q = 8,9 or q ≥ 16. © 2011 International Association for Cryptologic Research. Source

Kargin Y.,CWI Amsterdam
Proceedings of the ACM SIGMOD International Conference on Management of Data | Year: 2013

Nowadays scientists receive increasingly large volumes of data daily. These volumes and accompanying metadata that describes them are collected in scientific file repositories. Today's scientists need a data management tool that makes these file repositories accessible and performs a number of exploration steps near-instantly. Current database technology, however, has a long data-to-insight time, and does not provide enough interactivity to shorten the exploration time. We envision that exploiting metadata helps solving these problems. To this end, we propose a novel query execution paradigm, in which we decompose the query execution into two stages. During the first stage, we process only metadata, whereas the rest of the data is processed during the second stage. So that, we can exploit metadata to boost interactivity and to ingest only required data per query transparently. Preliminary experiments show that up-front ingestion time is reduced by orders of magnitude, while query performance remains similar. Motivated by these results, we identify the challenges on the way from the new paradigm to efficient interactive data exploration. Copyright © 2013 ACM. Source

Graefe G.,Hewlett - Packard | Felix H.,National University of Singapore | Idreos S.,CWI Amsterdam | Kuno H.,Hewlett - Packard | Manegold S.,CWI Amsterdam
Proceedings of the VLDB Endowment | Year: 2012

Adaptive indexing initializes and optimizes indexes incrementally, as a side effect of query processing. The goal is to achieve the benefits of indexes while hiding or minimizing the costs of index creation. However, index-optimizing side effects seem to turn readonly queries into update transactions that might, for example, create lock contention. This paper studies concurrency control in the context of adaptive indexing. We show that the design and implementation of adaptive indexing rigorously separates index structures from index contents; this relaxes the constraints and requirements during adaptive indexing compared to those of traditional index updates. Our design adapts to the fact that an adaptive index is refined continuously, and exploits any concurrency opportunities in a dynamic way. A detailed experimental analysis demonstrates that (a) adaptive indexing maintains its adaptive properties even when running concurrent queries, (b) adaptive indexing can exploit the opportunity for parallelism due to concurrent queries, (c) the number of concurrency conflicts and any concurrency administration overheads follow an adaptive behavior, decreasing a s the workload evolvesand adapting to the workload needs. © 2012 VLDB Endowment. Source

Ummels M.,RWTH Aachen | Wojtczak D.,CWI Amsterdam
Logical Methods in Computer Science | Year: 2011

We analyse the computational complexity of finding Nash equilibria in turnbased stochastic multiplayer games with ω-regular objectives. We show that restricting the search space to equilibria whose payoffs fall into a certain interval may lead to undecidability. In particular, we prove that the following problem is undecidable: Given a game G, does there exist a Nash equilibrium of G where player 0 wins with probability 1? Moreover, this problem remains undecidable when restricted to pure strategies or (pure) strategies with finite memory. One way to obtain a decidable variant of the problem is to restrict the strategies to be positional or stationary. For the complexity of these two problems, we obtain a common lower bound of NP and upper bounds of NP and Pspace respectively. Finally, we single out a special case of the general problem that, in many cases, admits an efficient solution. In particular, we prove that deciding the existence of an equilibrium in which each player either wins or loses with probability 1 can be done in polynomial time for games where the objective of each player is given by a parity condition with a bounded number of priorities. © M. Ummels and D. Wojtczak. Source

Chakraborty S.,Chennai Mathematical Institute | Garcia-Soriano D.,CWI Amsterdam | Matsliah A.,CWI Amsterdam
Proceedings of the Annual ACM-SIAM Symposium on Discrete Algorithms | Year: 2011

We study the problem of testing isomorphism (equivalence up to relabelling of the variables) of two Boolean functions f,g : {0, 1} n → {0,1}. Our main focus is on the most studied case, where one of the functions is given (explicitly) and the other function may be queried. We prove that for every k ≤ n, the worst-case query complexity of testing isomorphism to a given k-junta is Ω(fc) and O(k log k). Consequently, the query complexity of testing function isomorphism is Θ̃(n). Prior to this work, only lower bounds of Ω(log k) queries were known, for limited ranges of k, proved by Fischer et al. (FOCS 2002), Biais and O'Donnell (CCC 2010), and recently by Alon and Biais (RANDOM 2010). The nearly tight O(k log k) upper bound improves on the Õ(k 4) upper bound from Fischer et al. (FOCS 2002). Extending the lower bound proof, we also show polynomial query-complexity lower bounds for the problems of testing whether a function can be computed by a circuit of size ≤ s, and testing whether the Fourier degree of a function is ≤ d. This answers questions posed by Diakonikolas et al. (FOCS 2007). We also address two closely related problems - 1. Testing isomorphism to a k-junta with one-sided error: we prove that for any 1 < k < n - 1, the query complexity is Ω (log ( n k)), which is almost optimal. This lower bound is a consequence of a proof that the query complexity of testing, with one-sided error, whether a function is a k-parity is Θ (log ( n k)). 2. Testing isomorphism between two unknown functions that can be queried: we prove that the query complexity in this setting is Ω(√2 n) and O(√2 nn log n). Source

Discover hidden collaborations