96 research outputs found

    Lower Bounds for Monotone Span Programs

    Get PDF
    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

    Get PDF
    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

    Full text link
    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

    Get PDF
    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 nn-party access structure, the best known upper bound on the share size is 2O(n)2^{O(n)}. On the other hand, the best known lower bound on the total share size is much smaller, i.e., Ω(n2/log(n))\Omega(n^2/\log (n)) [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 kk-hypergraphs, i.e., for access structures where all minimal authorized sets are of size exactly kk (however, unauthorized sets can be larger). We consider the case where kk is small, i.e., constant or at most log(n)\log (n). The trivial upper bound for these access structures is O(n(n1k1))O(n\cdot \binom{n-1}{k-1}) and this can be slightly improved. If there were efficient secret-sharing schemes for such kk-hypergraphs (e.g., 22-hypergraphs or 33-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 kk-hypergraphs is important. Prior to our work, the best known lower bound for these access structures was Ω(nlog(n))\Omega(n \log (n)), which holds already for graphs (i.e., 22-hypergraphs). We improve this lower bound, proving a lower bound of Ω(n21/(k1)/k)\Omega(n^{2-1/(k-1)}/k) on the total share size for some explicit kk-hypergraphs, where 3klog(n)3 \leq k \leq \log (n). For example, for 33-hypergraphs we prove a lower bound of Ω(n3/2)\Omega(n^{3/2}). For log(n)\log (n)-hypergraphs, we prove a lower bound of Ω(n2/log(n))\Omega(n^{2}/\log (n)), i.e., we show that the lower bound of Csirmaz holds already when all minimal authorized sets are of size log(n)\log (n). 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 Ω(n2/log(n))\Omega(n^2/\log(n)) and the monotone circuit size is O(nlog(n))O(n\log(n)) (where the circuit has depth 33)

    The Share Size of Secret-Sharing Schemes for Almost All Access Structures and Graphs

    Get PDF
    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 20.59n2^{0.59n} (Applebaum and Nir, CRYPTO 2021) and the best known lower bound of Ω(n/logn)\Omega(n/\log n) (Csirmaz, J. of Cryptology 1997) is huge (where nn 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 2O~(n)2^{\tilde{O}(\sqrt{n})}. 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 - O(n/logn)O(n/\log n) (Erdös and Pyber, Discrete Mathematics 1997) - and the lower bounds - Ω(logn)\Omega(\log n) (van Dijk, Des. Codes Crypto. 1995). We show that for almost all graphs, the share size of each party is no(1)n^{o(1)}. 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

    Get PDF
    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 O~(2n)\tilde{O}(2^{n}) (where nn 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 O~(20.994n)\tilde{O}(2^{0.994n}). The construction is based on new protocols for conditional disclosure of secrets (CDS). This was improved by Applebaum et al. [EUROCRYPT 2019] to O~(20.892n)\tilde{O}(2^{0.892n}). In this work, we construct improved secret-sharing schemes for a general access structure with share size O~(20.762n)\tilde{O}(2^{0.762n}). 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 O~(20.942n)\tilde{O}(2^{0.942n}). 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 ff, there are kk 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 ff applied to the inputs returns 11, 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 ff applied to the inputs returns 00, 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 tt-robust CDS protocols, where the referee cannot get any information on the secret when it gets tt messages for a set of zero-inputs of ff. We show that if a function ff has a two-party CDS protocol with message size cfc_f, then it has a two-party tt-robust CDS protocol with normalized message size O~(tcf)\tilde{O}(t c_f). Furthermore, we show that every function f:[N]×[N]{0,1}f:[N] \times [N]\rightarrow \{0,1\} has a multi-linear tt-robust CDS protocol with normalized message size O~(t+N)\tilde{O}(t+\sqrt{N}). We use a variant of this protocol (with tt slightly larger than N\sqrt{N}) to construct our improved linear secret-sharing schemes. Finally, we construct robust kk-party CDS protocols for k>2k>2
    corecore