96 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
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 )
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
Secret-Sharing from Robust Conditional Disclosure of Secrets
A secret-sharing scheme is a method by which a dealer, holding a secret string, distributes shares to parties such that only authorized subsets of parties can reconstruct the secret.
The collection of authorized subsets is called an access structure.
Secret-sharing schemes are an important tool in cryptography and they are used as a building box in many secure
protocols.
In the original constructions of secret-sharing schemes by Ito et al. [Globecom 1987], the share size of each party is (where is the number of parties in the access structure).
New constructions of secret-sharing schemes followed; however, the share size in these schemes remains basically the same.
Although much efforts have been devoted to this problem, no progress was made for more than 30 years.
Recently, in a breakthrough paper, Liu and Vaikuntanathan [STOC 2018] constructed a secret-sharing scheme for a general access structure with share size .
The construction is based on new protocols for conditional disclosure of secrets (CDS).
This was improved by Applebaum et al. [EUROCRYPT 2019] to .
In this work, we construct improved secret-sharing schemes for a general access structure with share size .
Our schemes are linear, that is, the shares are a linear function of the secret and some random elements from a finite field.
Previously, the best linear secret-sharing scheme had shares of size .
Most applications of secret-sharing require linearity. Our scheme is conceptually simpler than previous schemes, using a new reduction to two-party CDS protocols (previous schemes used a reduction to multi-party CDS protocols).
In a CDS protocol for a function , there are parties and a referee; each party holds a private input and a common secret, and sends one message to the referee (without seeing the other messages).
On one hand, if the function applied to the inputs returns , then it is required that the referee, which knows the inputs, can reconstruct the secret from the messages.
On the other hand, if the function applied to the inputs returns , then the referee should get no information on the secret from the messages. However, if the referee gets two messages from a party, corresponding to two different inputs (as happens in our reduction from secret-sharing to CDS), then the referee might be able to reconstruct the secret although it should not.
To overcome this problem, we define and construct -robust CDS protocols, where the referee cannot get any information on the secret when it gets messages for a set of zero-inputs of .
We show that if a function has a two-party CDS protocol with message size , then it has a two-party -robust CDS protocol with normalized message size .
Furthermore, we show that every function has a multi-linear -robust CDS protocol with normalized message size .
We use a variant of this protocol (with slightly larger than ) to construct our improved linear secret-sharing schemes.
Finally, we construct robust -party CDS protocols for
- …