111 research outputs found
Lower Bounds for Monotone Span Programs
The model of span programs is a linear algebraic model of computation. Lower bounds for span programs imply lower bounds for contact schemes, symmetric branching programs and for formula size. Monotone span programs correspond also to linear secret-sharing schemes. We present a new technique for proving lower bounds for monotone span programs. The main result proved here yields quadratic lower bounds for the size of monotone span programs, improving on the largest previously known bounds for explicit functions. The bound is asymptotically tight for the function corresponding to a class of 4-cliques
Exploring Differential Obliviousness
In a recent paper, Chan et al. [SODA \u2719] proposed a relaxation of the notion of (full) memory obliviousness, which was introduced by Goldreich and Ostrovsky [J. ACM \u2796] and extensively researched by cryptographers. The new notion, differential obliviousness, requires that any two neighboring inputs exhibit similar memory access patterns, where the similarity requirement is that of differential privacy. Chan et al. demonstrated that differential obliviousness allows achieving improved efficiency for several algorithmic tasks, including sorting, merging of sorted lists, and range query data structures.
In this work, we continue the exploration of differential obliviousness, focusing on algorithms that do not necessarily examine all their input. This choice is motivated by the fact that the existence of logarithmic overhead ORAM protocols implies that differential obliviousness can yield at most a logarithmic improvement in efficiency for computations that need to examine all their input. In particular, we explore property testing, where we show that differential obliviousness yields an almost linear improvement in overhead in the dense graph model, and at most quadratic improvement in the bounded degree model. We also explore tasks where a non-oblivious algorithm would need to explore different portions of the input, where the latter would depend on the input itself, and where we show that such a behavior can be maintained under differential obliviousness, but not under full obliviousness. Our examples suggest that there would be benefits in further exploring which class of computational tasks are amenable to differential obliviousness
Secure Multiparty Computation with Partial Fairness
A protocol for computing a functionality is secure if an adversary in this
protocol cannot cause more harm than in an ideal computation where parties give
their inputs to a trusted party which returns the output of the functionality
to all parties. In particular, in the ideal model such computation is fair --
all parties get the output. Cleve (STOC 1986) proved that, in general, fairness
is not possible without an honest majority. To overcome this impossibility,
Gordon and Katz (Eurocrypt 2010) suggested a relaxed definition -- 1/p-secure
computation -- which guarantees partial fairness. For two parties, they
construct 1/p-secure protocols for functionalities for which the size of either
their domain or their range is polynomial (in the security parameter). Gordon
and Katz ask whether their results can be extended to multiparty protocols.
We study 1/p-secure protocols in the multiparty setting for general
functionalities. Our main result is constructions of 1/p-secure protocols when
the number of parties is constant provided that less than 2/3 of the parties
are corrupt. Our protocols require that either (1) the functionality is
deterministic and the size of the domain is polynomial (in the security
parameter), or (2) the functionality can be randomized and the size of the
range is polynomial. If the size of the domain is constant and the
functionality is deterministic, then our protocol is efficient even when the
number of parties is O(log log n) (where n is the security parameter). On the
negative side, we show that when the number of parties is super-constant,
1/p-secure protocols are not possible when the size of the domain is
polynomial
Characterizing the Sample Complexity of Private Learners
In 2008, Kasiviswanathan et al. defined private learning as a combination of
PAC learning and differential privacy. Informally, a private learner is applied
to a collection of labeled individual information and outputs a hypothesis
while preserving the privacy of each individual. Kasiviswanathan et al. gave a
generic construction of private learners for (finite) concept classes, with
sample complexity logarithmic in the size of the concept class. This sample
complexity is higher than what is needed for non-private learners, hence
leaving open the possibility that the sample complexity of private learning may
be sometimes significantly higher than that of non-private learning.
We give a combinatorial characterization of the sample size sufficient and
necessary to privately learn a class of concepts. This characterization is
analogous to the well known characterization of the sample complexity of
non-private learning in terms of the VC dimension of the concept class. We
introduce the notion of probabilistic representation of a concept class, and
our new complexity measure RepDim corresponds to the size of the smallest
probabilistic representation of the concept class.
We show that any private learning algorithm for a concept class C with sample
complexity m implies RepDim(C)=O(m), and that there exists a private learning
algorithm with sample complexity m=O(RepDim(C)). We further demonstrate that a
similar characterization holds for the database size needed for privately
computing a large class of optimization problems and also for the well studied
problem of private data release
Lower Bounds for Secret-Sharing Schemes for k-Hypergraphs
A secret-sharing scheme enables a dealer, holding a secret string, to distribute shares to parties such that only pre-defined authorized subsets of parties can reconstruct the secret. The collection of authorized sets is called an access structure. There is a huge gap between the best known upper bounds on the share size of a secret-sharing scheme realizing an arbitrary access structure and the best known lower bounds on the size of these shares. For an arbitrary -party access structure, the best known upper bound on the share size is . On the other hand, the best known lower bound on the total share size is much smaller, i.e., [Csirmaz, \emph{Studia Sci. Math. Hungar.}]. This lower bound was proved more than 25 years ago and no major progress has been made since.
In this paper, we study secret-sharing schemes for -hypergraphs, i.e., for access structures where all minimal authorized sets are of size exactly (however, unauthorized sets can be larger). We consider the case where is small, i.e., constant or at most . The trivial upper bound for these access structures is and this can be slightly improved. If there were efficient secret-sharing schemes for such -hypergraphs (e.g., -hypergraphs or -hypergraphs), then we would be able to construct secret-sharing schemes for arbitrary access structures that are better than the best known schemes. Thus, understanding the share size required for -hypergraphs is important. Prior to our work, the best known lower bound for these access structures was , which holds already for graphs (i.e., -hypergraphs). We improve this lower bound, proving a lower bound of on the total share size for some explicit -hypergraphs, where . For example, for -hypergraphs we prove a lower bound of . For -hypergraphs, we prove a lower bound of , i.e., we show that the lower bound of Csirmaz holds already when all minimal authorized sets are of size . Our proof is simple and shows that the lower bound of Csirmaz holds for a simple variant of the access structure considered by Csirmaz. Using our results, we prove a near quadratic separation between the required share size for realizing an explicit access structure and the monotone circuit size describing the access structure,i.e., the share size in and the monotone circuit size is (where the circuit has depth )
Exploring Differential Obliviousness
In a recent paper Chan et al. [SODA '19] proposed a relaxation of the notion
of (full) memory obliviousness, which was introduced by Goldreich and Ostrovsky
[J. ACM '96] and extensively researched by cryptographers. The new notion,
differential obliviousness, requires that any two neighboring inputs exhibit
similar memory access patterns, where the similarity requirement is that of
differential privacy. Chan et al. demonstrated that differential obliviousness
allows achieving improved efficiency for several algorithmic tasks, including
sorting, merging of sorted lists, and range query data structures.
In this work, we continue the exploration and mapping of differential
obliviousness, focusing on algorithms that do not necessarily examine all their
input. This choice is motivated by the fact that the existence of logarithmic
overhead ORAM protocols implies that differential obliviousness can yield at
most a logarithmic improvement in efficiency for computations that need to
examine all their input. In particular, we explore property testing, where we
show that differential obliviousness yields an almost linear improvement in
overhead in the dense graph model, and at most quadratic improvement in the
bounded degree model. We also explore tasks where a non-oblivious algorithm
would need to explore different portions of the input, where the latter would
depend on the input itself, and where we show that such a behavior can be
maintained under differential obliviousness, but not under full obliviousness.
Our examples suggest that there would be benefits in further exploring which
class of computational tasks are amenable to differential obliviousness
The Share Size of Secret-Sharing Schemes for Almost All Access Structures and Graphs
The share size of general secret-sharing schemes is poorly understood. The gap between the best known upper bound on the total share size per party of (Applebaum and Nir, CRYPTO 2021) and the best known lower bound of (Csirmaz, J. of Cryptology 1997) is huge (where is the number of parties in the scheme). To gain some understanding on this problem, we study the share size of secret-sharing schemes of almost all access structures, i.e., of almost all collections of authorized sets. This is motivated by the fact that in complexity, many times almost all objects are hardest (e.g., most Boolean functions require exponential size circuits). All previous constructions of secret-sharing schemes were for the worst access structures (i.e., all access structures) or for specific families of access structures.
We prove upper bounds on the share size for almost all access structures. We combine results on almost all monotone Boolean functions (Korshunov, Probl. Kibern. 1981) and a construction of (Liu and Vaikuntanathan, STOC 2018) and conclude that almost all access structures have a secret-sharing scheme with share size .
We also study graph secret-sharing schemes. In these schemes, the parties are vertices of a graph and a set can reconstruct the secret if and only if it contains an edge. Again, for this family there is a huge gap between the upper bounds - (Erdös and Pyber, Discrete Mathematics 1997) - and the lower bounds - (van Dijk, Des. Codes Crypto. 1995). We show that for almost all graphs, the share size of each party is . This result is achieved by using robust 2-server conditional disclosure of secrets protocols, a new primitive introduced and constructed in (Applebaum et al., STOC 2020), and the fact that the size of the maximal independent set in a random graph is small. Finally, using robust conditional disclosure of secrets protocols, we improve the total share size for all very dense graphs
- …