Lower bounds in differential privacy
Anindya De
Introduction
This is a paper about private data analysis, in which a trusted curator holding a confidential database responds to real vector-valued queries. Specifically, we focus on the practice of ensuring privacy for the database elements by adding appropriately generated random noise to the answers, releasing only these noisy responses. A line of study initiated by Dinur and Nissim examines the amount of distortion needed to prevent privacy violations of various kinds [DN03]. Dinur and Nissim did not have a definition of privacy; rather, they had a notion that has come to be called blatant non-privacy; the modest goal, then, was to add enough distortion to avert blatant non-privacy. Since that time, the community has raised the bar by definining (and achieving) powerful and comprehensive notions of privacy [DN03, DMNS06, DKM+06], and the goal has been to preserve -differential privacy and its relaxation, -differential privacy. A final goal considered herein, attribute privacy, has a more complicated description, but may be thought of as preventing blatant non-privacy for a single data attribute [KRSU10] in the presence of a certain kind of contingency table query.
The results in the literature vary according to several parameters, including the number of elements in the database, the size of the universe from which data elements are drawn, the “amount” and type of privacy desired, and for the purposes of the current work, the arity of the query. In this paper we strengthen and unify these bounds.
As corollaries of our work, we obtain several “structural” results regarding different types of privacy guarantees:
We separate so-called counting queries from arbitrary low-sensitivity queries, proving the latter requires more noise, or distortion, than does the former;
We separate -differential privacy from its well-studied relaxation -differential privacy, even when is negligible in the size of the database, proving the latter requires less distortion than the former;
We demonstrate that -differential privacy is much weaker than -differential privacy in terms of mutual information of the transcript of the mechanism with the database even when is negligible in the size of the database.
To describe our results even at a high level we must outline the privacy-preserving database model, the notion of distortion or noise that may be employed in order to preserve privacy, and the meaning of the goals of the adversary: blatant non-privacy, violation of -differential privacy, violation of - differential privacy, and attribute non-privacy.
Typically, the curator of a database receives questions to which it responds with potentially noisy answers. There are two possible settings here. One is that the queries are received by the curator one at a time. The other situation is that all the queries are received by the curator at once and it then publishes (noisy) answers to all of them at once. The former is called the interactive setting and the latter is called the non-interactive setting. All our lower bounds are in the non-interactive setting making them applicable to the interactive setting as well.
We now formally introduce the definition of mechanism and privacy.
We next state the definition of -differential privacy (introduced by Dwork et al. in [DMNS06]) and -differential privacy (introduced by Dwork et al. in [DKM+06]).
The mechanism is said to be -differentially private if
Typically, is set to be negligible in .
We remark that we do not define the notion of noise very precisely here as the notion of noise depends on the context. However, in the context of differential privacy, we use the following definition of noise.
While differential privacy is a very strong notion of privacy, sometimes one can show that even very modest definitions of privacy get violated. One such notion is that of blatant non-privacy. We say that a mechanism for answering over databases of size and universe size is blatantly non-private, if there is an attack such that w.h.p. over the answer returned by the mechanism , differs from the database only at fraction of the places. Yet another very weak notion of privacy that is interesting to us is that of attribute non-privacy. The formal definition follows :
where simply denotes the obvious concatenation of and . need not be computationally efficient and the constant is arbitrary and can be replaced by any positive constant.
We give tight lower bounds on noise for ensuring -differential privacy for . This proof relies on a lemma due to [MMP+10] showing that -differentially private mechanisms yield a certain kind of unpredictable source. On the other hand, any mechanism that is blatantly non-private cannot yield an unpredictable source. Thus, if the noise is insufficient to prevent blatant non-privacy then it cannot provide -differential privacy. We subsequently use the lower bounds of [DN03, DMT07] for preventing blatant non-privacy to get lower bounds on the distortion for differential privacy.
We show new lower bounds for blatant non-privacy for the case when the size of the universe is smaller than the size of the database. In particular, we show that there is a counting query such that if the distortion added on at least fraction of the answers is bounded by (for some ), then there is an attack which recovers a database different from the original database by . Our analysis makes use of a result on large deviation of Rademacher sums.
Lower bound by volume arguments
We now recall the volume based argument of Hardt and Talwar [HT10] to show lower bounds on the noise required for differential privacy.
While the line of reasoning in the proof is same as that of [HT10], we do the proof here as the argument in [HT10] works only for counting queries i.e., when is a linear transformation. On the other hand, the statement and proof of our result works for any query .
However, we can also say that because the noise added by the mechanism is at most ,
Also, because the mechanism is -differentially private and , then
This leads to a contradiction if thus proving the assertion.
In this subsection, we prove the following theorem.
Before starting the proof, we make a couple of observations. First of all, note that the statement of the theorem does not give any lower bound for . However, any mechanism which is -differentially private for in the aforementioned range is also -differentially private for . Hence, the noise lower bounds for -differential privacy for are also applicable for the range of . It is easy to see that up to constant factors, the lower bounds with are optimal for in the aforementioned range.
Secondly, we note that it is enough to add noise to maintain -differential privacy (using the Laplacian mechanism). Also, because the databases are of size , it is enough to add noise to maintain -differential privacy for any . Thus, as long as , our lower bounds are tight up to constant factors. Next, we do the proof of Theorem 2.2.
For every , there is a coordinate in the mapping.
The coordinate of is .
The map is -Lipschitz i.e., if , then .
Proof: We observe that for any such that , if denotes the set of coordinates where at least one of or are non-zero, then is either empty or is a singleton set. Given this, the statement in the claim is obvious, since the mapping corresponding to any particular coordinate is clearly -Lipschitz.
Now consider any such that . Because of the way is defined, it is clear that for any ,
A basic application of the Chernoff bound implies that
This implies that we can fix such that the following is true.
For the subsequent part of this paper, we only consider lower bounds on -differential privacy for as opposed to . This is because the privacy guarantees one gets becomes unmeaningful when is large. However, we do remark that the results can be carried in a straightforward way to the regime of using combinatorial designs (like we did for Theorem 2.2).
The next consequence is a separation of differential privacy from differential privacy for . We note that Hardt and Talwar [HT10] had shown such a separation but that was only when and . Again, we use the setting of parameters when and . The gaussian mechanism of [DKM+06] shows that to maintain differential privacy for any queries, it sufficies to add noise . However, Theorem 2.2 shows that there is a query which requires adding noise to maintain differential privacy.
The last consequence of our result is more indirect and is explained next.
2 Information loss in differentially private protocols
In [MMP+10], a connection was established between differentially private protocols and the notion of mutual information from information theory. In fact, as [MMP+10] was dealing with 2-party protocols, the connection was actually between differentially private protocols and that of information content [BYJKS04, BBCR10] which is a symmetric variant of mutual information useful in 2-party protocols. In that paper, it was shown that the information content (which simplifies to mutual information in our setting) between transcript of a -differentially private mechanism and the database vector is bounded by . Using the construction used in the previous subsection, we show that in case of differentially private protocols (for any ), there is no non-trivial bound on the mutual information between the transcript of the mechanism and the database vector. Thus as far as information theoretic guarantees go, the situation is drastically different for pure differentially private protocols vis-a-vis approximately differentially private protocols. The contents of this subsection are a result of personal communication between the author and Salil Vadhan [DV10].
We first define the notion of mutual information (can be found in standard information theory textbooks).
Given two random variables and , their mutual information is defined as
where denotes the Shannon entropy of .
The next claim establishes an upper bound on the mutual information between transcript of a differentially private protocol and the database vector.
Next, we state the following claim which says that for differentially private protocols, even for an exponentially small , the mutual information between the transcript and the input can be as large as for any value of . In other words, an differentially private protocol does not imply any effective bound on the mutual information between the input and the transcript even as and is exponentially small.
Proof: We first construct vectors in (for ) with the property that for any , . It is easy to guarantee the existence of such a set of vectors by a simple application of the probabilistic method. The distribution is simply the uniform distribution over the set . By construction, all the databases in are of size bounded by .
Note that for the above mechanism , and database , if is sampled from , then the distribution of is same as where each is an i.i.d. random variable. Thus,
As the following fact shows, the distribution on the right hand side is concentrated around its mean. The fact is possibly well-known but we could not find a reference and hence we prove it in Appendix C.
If are i.i.d. random variables, then,
Here the probability is over the randomness of the mechanism. Putting and for an appropriate constant , we get that
As we know, for any , . Hence, with probability at least over the randomness of the mechanism, for any database , if is sampled from ,
Thus, for any , given , we can recover with high probability and hence, we can say
Recall that . This completes the proof of the Lemma 2.6.
Lower bound on noise for counting queries
Next, we prove the same result without making any such technical assumptions. Again, our constructions are dependent on combinatorial designs [Pau85]. First, we prove the following simple but useful claim.
where .
We now prove a lower bound on the noise required to maintain privacy for random counting queries. As we have said before, Hardt and Talwar [HT10] proved the same result under an additional assumption that the mechanism defined over integral databases can be smoothly extended to fractional databases as well.
Proof: The proof strategy is to come up with databases meeting the hypothesis of Claim 3.1 and use Claim 3.1 to get a counting query . We then use Theorem 2.1 to get a lower bound on the distortion required by any private mechanism to answer . We consider two cases : and .
, and ,
Again, we have databases which differ by at most and hence we can apply Theorem 2.1 to get that to maintain -differential privacy, any mechanism needs to add noise.
Lower bounds for approximate differential privacy
In this section, we consider databases which are elements of or in other words we consider the case when the universe size and the databases are allowed to have exactly one element of each type. We note that restricting databases to bit vectors is a well-considered model in literature including [DN03, DMT07, MMP+10] among others.
is not differentially private. In other words, any mechanism which with significant probability i.e., answers at least fraction of the queries with at most noise, is not differentially private.
To do the proof of Theorem 4.1, we first need to introduce some definitions previously discussed in [MMP+10]. We do note that the paper [MMP+10] deals with the two-party setting but the relevant definitions and the lemma we use here easily extend to the standard (curator-client) setting of privacy.
A random variable is said to be -approximate strongly -unpredictable bit source (for ) if with probability over and
The next lemma (proven in [MMP+10] for the two-party setting) roughly says that for any private mechanism, conditioned on the transcript of the mechanism, the distribution of the database is a -approximate strong -unpredictable source. More precisely, we have the following lemma.
The above lemma trivially follows from Lemma 20 of [MMP+10] (full version) and hence we do not prove it here. Before, proving Theorem 4.1, we need to recall the following theorem from [DMT07] (Theorem 24 in the paper).
The following corollary follows immediately from Theorem 4.4.
Let denote the uniform distribution over . First, using Lemma 4.3, we get that over the randomness of the mechanism and the choice of , if we sample a transcript from , then for any positive , the distribution is a -approximate strongly -unpredictable sources where satisfies
for . Clearly such a mechanism is not differentially private because with probability at least , the algorithm will be able to predict at least fraction of the positions which contradicts that with probability , the distribution is a -approximate strongly -unpredictable source.
In this section, we consider attacks on privacy using linear programming. In particular, we use the technique of LP decoding (previously used in [DMT07] in context of privacy) to give attacks which violate even minimal notions of privacy when (for some ) fraction of the queries are released with insufficient noise. We do this by establishing a connection between Euclidean sections and use of LP decoding in context of privacy which does not seem to have explicitly appeared in the literature before. We remark that the relation between LP decoding and Euclidean spaces is very well known in context of compressed sensing [CRTV05]. However, in case of privacy, the adversary is allowed to add small error to say of the entries and arbitrary error to the remaining of the entries. In context of compressed sensing however, the adversary is allowed to add error to only of the entries.
where .
Proof: Let and . Then, by Jensen’s inequality, we can say that
We get the stated result by putting .
Let . Then, from the above, we get that
We next use on the right hand side of the above inequality to simplify and get
Combining the above with (3), we get that
Similarly, consider any and define i.e., represents the number of non-zero entries in . We note that the set defined as
Now, for any and , we define as follows :
In other words, is iff the following holds for every : If , then and if , then .
We now state our main theorem of this section.
is attribute non-private. Further, the algorithm which violates attribute privacy is efficient and uses LP decoding.
Here is an iterated logarithm which is defined precisely later on. However, we wanted to state the main result of this section in the beginning itself before diving into the proof structure.
Before, we glimpse into how they prove their result and our improvement on that, we need to describe the Hadamard product of matrices.
where represents the element in row and column .
The attack in [KRSU10] is an efficient algorithm (is simply matrix inversion) and is basically dependent on showing existence of a Hadamard product of small matrices such that all its singular values are large. In particular, they show the following reduction.
Subsequently, to prove Theorem 5.5, they proved the following lemma.
To describe the main technical result of Rudelson [Rud11], we need to define iterated logarithms.
Theorem 5.11 and Lemma 5.9 immediate imply our main theorem which we restate here for convenience.
is attribute non-private. Further, the algorithm which violates attribute privacy is efficient and uses LP decoding.
Noise lower bounds for blatant non-privacy
In this section, we prove lower bounds on the noise required to prevent blatant non-privacy while answering random counting queries. Dinur and Nissim [DN03], in their seminal paper, had shown that answering subset sum queries with noise results in blatant non-privacy. In other words, they had proven the following theorem.
The algorithm in the above result is efficient and uses linear programming. Since then, several improvements were made to this result including the results in [DMT07] where the same conclusion was achieved under the weaker hypothesis that
for any . While the attack was inefficient, they also showed how to use LP decoding to get an efficient attack and they could achieve this under the weaker hypothesis
Before going ahead with the proof, we remark that while both the algorithms and , as described in the proof are inefficient, the former can be made efficient using linear programming (along the lines of [DN03, DMT07]). We choose not to do it for the sake if simplicity.
we get that for all such that ,
Thus, when we have the query described above, the algorithm will never return if and hence the correctness is proven.
We now come to the second part of the theorem. The algorithm is described as follows :
Return if ,
This means that putting
Hence, we get that (for all such that )
This shows that algorithm will never return if and hence the correctness is proven.
Acknowledgements
First and foremost, I would like to thank Cynthia Dwork for introducing me to the problems discussed in this paper, immense help with the presentation and the technical help. Even though she declined to co-author the paper, without her contributions, this paper would not have existed. This work was almost entirely done during a very enjoyable summer in 2010 at MSR Silicon Valley while the author was a summer intern with her. I would also like to thank Salil Vadhan for his kind permission to include the results of subsection 2.2 in this paper.
The author would like to thank Moritz Hardt and Mark Rudelson for very helpful conversations. The question of getting a lower bound for blatant non-privacy with dependence on universe size came up in a discussion with Moritz Hardt. I would like to thank Mark for answering countlessly many questions about random matrices and anti-concentration. I also had useful conversations about this work with Ilya Mironov, Elchanan Mossel, Omer Reingold, Adam Smith, Alexandre Stauffer, Kunal Talwar, and Salil Vadhan.
I would also like to thank the SODA 2012 and TCC 2012 reviewers for many useful comments including pointing out an error in the earlier proof of Lemma 2.6.
References
Appendix A Construction of databases with large differences
, and
Proof: We use construction of combinatorial designs from [Pau85, RRV99]. Namely, the main theorem in [Pau85] states that it is possible to construct sets with the following properties :
,
Now, consider the set be the characteristic vectors of the sets . Now, we observe that setting achieves all the stated conditions.
and ,
Proof: Consider a set with the following two properties.
, ,
, .
Such a set exists. To see this, consider an error correction code with distance and rate . Such a code exists via probabilistic method. Now, the set is constructed as
We claim that the set satisfies the required conditions. The first and the third parts of claim are obvious. Note that for any , . The penultimate inequality uses that .
The above claim worked for . We now prove a claim which works in the regime of .
and ,
Further, is in fact a subset of .
Proof: We observe that the construction of set is related to the construction of combinatorial designs [Pau85, RRV99] with specific parameters. In particular, the result in [Pau85] allows us to construct sets with the following properties :
,
,
provided that (for some large constant ). Using the conditions on and , we see that the condition is satisfied provided is sufficiently large compared to . Clearly, if are characteristic vectors of the sets respectively, then
Appendix B Large deviation of Rademacher sums from their mean
In this section, we prove the following inequality which says that Rademacher sums have large deviations from their mean with significant probability.
An immediate application of the above theorem is the following corollary.
The following theorem about large deviation of Rademacher sums from the mean was proven by Montgomery-Smith [MS90].
To use Theorem B.3 in order to prove the Theorem B.1, we make the following claim.
The theorem immediately follows by plugging the lower bound on from the above claim in Theorem B.3.
Appendix C Concentration of measure for the sum of squares of Gaussians
In this section, we prove a result about the concentration of measure for the sum of squares of i.i.d. random variables. While this seems to be a well studied distribution in literature, we could not find a usable result on its concentration and hence we prove the following theorem here.
Let be i.i.d. random variables. Then,
Proof: Note that by definition, for any ,
Then, consider the random variable . We note that
Using independence of the ’s, we get that the above expression is
Putting , we get that the above expression is