betaFeedback

WorksComputer Science

Complexity of Differentially Private Selection via Federated APIs

Abstract

Differential privacy (DP) has become the standard for privacy-preserving data analysis, yet its practical implementation in federated or distributed settings often faces a significant utility gap compared to the central model. While existing frameworks, including local, shuffle, and secure aggregation models, offer vetted primitives, they can incur high error for important tasks such as selection. Our first contribution is to show that this is inherent in the aggregation model: any private selection algorithm relying on the standard noisy aggregation primitive requires Ω(d/ε)Ω(\sqrt{d}/\varepsilon) samples. To address this limitation, we propose adding a new primitive that implements a version of the Sparse Vector Technique (SVT) and argue that it has simple implementations under various trust models. We demonstrate its power by developing an ε\varepsilon-differentially private algorithm for the selection problem. For selection in dimension dd, our algorithm achieves an additive error of O(log⁡(dn)ε)O\left(\frac{\log(dn)}{\varepsilon}\right), matching that of the central model when nn is polynomially bounded in dd. Furthermore, we show that this can be done using a near-optimal expected number O(dlog⁡∗d)O(d\log^*d) of SVT queries. Together with existing lower bounds for the shuffle model, this result establishes an exponential separation between the SVT model and shuffle or aggregation-based models. We demonstrate the model's broad applicability to diverse tasks such as FpF_p loss minimization, heavy-hitter identification, and sparse mean estimation.

Introduction

Differential privacy (DP) [30, 32] has emerged as the gold standard for privacy-preserving data analysis, offering a mathematically rigorous framework that limits the risk of disclosing the data of any individual entity. Informally, a randomized algorithm is differentially private if its output distribution is nearly unchanged when any individual record is modified or removed. This ensures that adversaries learn little about any one participant, even with auxiliary information.

Despite its mathematical elegance, the practical implementation and verification of differential privacy can be challenging [14, 3, 44, 7, 5, 9, 69]. Because privacy guarantees are probabilistic and often counterintuitive, even subtle coding errors or floating-point vulnerabilities can lead to privacy leakage [54]. This has led the community toward primitives that avoid floating-point numbers [21, 18]. More broadly, verifying that an implementation of a differentially private algorithm is correct can be challenging, and even testing or auditing for privacy requires considerable effort [8, 43].

To mitigate these risks, the field has moved toward a modular “API-centric” approach. Rather than requiring developers to implement complex mechanisms from scratch, privacy frameworks, dating from early systems like PINQ [53] and Airavat [59] to modern efforts like OpenDP and Google’s differential privacy building blocks, rely on a small set of vetted primitives. These primitives are the “building blocks” for private algorithms; by thoroughly auditing a limited number of functions, such as the Laplace mechanism or standard composition theorems, one can build complex pipelines while mathematically tracking the total privacy loss.

In federated or distributed architectures, implementing such primitives is harder, and thus this modularity is even more critical. Specifically, primitives must be implemented under a variety of operational and security constraints. The move toward these standardized, vetted interfaces has led to the adoption of large-scale DP frameworks [62, 68], which provide high-level query languages backed by reliable primitives. However, as the ecosystem of these frameworks expands, it becomes vital to understand the relative power of various primitives.

Previous work has successfully formalized specific trust models, such as the local [67, 35, 50] and shuffle [4, 22, 34] privacy models. More broadly, a privacy framework can treat simple privacy primitives as interchangeable building blocks and support a set of privacy-accounting methods. A complex algorithm can be built by combining primitives, each run on all or a subset of the data, while privacy accounting upper bounds the algorithm’s privacy cost. As an example, an aggregation system allows for algorithms that apply a function f:X→Rdf : \mathcal{X} \to\mathbb{R}^{d} to each individual data point and output a noisy aggregate f~(x1,…,xn)=∑iclip⁡1(f(xi))+N(0,σ2Id)\tilde{f}(x_{1}, \ldots, x_{n}) = \sum_{i} \operatorname{clip}_{1}(f(x_{i})) + \mathcal{N}(0, \sigma^{2} I_{d}), for a user-specified noise parameter σ\sigma, where clip⁡1\operatorname{clip}_{1} is the standard function that truncates the input to have ℓ2\ell_{2} norm at most 1. A Rényi accountant in this setting would accumulate privacy cost in terms of Rényi DP [55]. One can then use such a system to implement differentially private gradient descent to train a machine learning model. Enhancing the primitive and accounting to allow for privacy amplification by sampling further enables DP stochastic gradient descent [16, 1]. Aggregation, potentially with sampling, can support a rich class of algorithms, and such systems have been proposed under various assumptions [28, 12 RCWH+20, FES+17, 58, 60 TWM+24].

In this work, we study the limits of the Aggregation API, and propose an additional primitive to help circumvent some of these limitations.

Our Contributions

Despite the wide applicability of the Aggregation API, there are important tasks that are not known to be implementable accurately using aggregation alone. Foremost among these is perhaps the selection problem, where the best-known algorithms using aggregation incur significant overhead compared to the optimal central-DP bounds: while centrally one can do selection using O(log⁡d/ε)O(\log d/\varepsilon) samples, existing implementations using aggregation require Ω(d/ε)\Omega(\sqrt{d}/\varepsilon) samples. While this sample complexity is provably required (sometimes under additional assumptions) for weaker APIs such as local and shuffle DP [26, 22, 24, 20], no existing lower bounds exclude a better way to do selection using an aggregation API.

Our first result is a strong lower bound ruling out this possibility. We show that any selection algorithm using an aggregation API requires sample complexity Ω(d/ϵ)\Omega(\sqrt{d}/\epsilon) if it guarantees (ϵ,δ)(\epsilon,\delta)-DP for any implementation of the aggregation API and can identify a dimension whose average score is 1/31/3 more than all the others.

Theorem 2.1. [Informal] Any (O(1),O(1/poly⁡(d)))(O(1),O(1/\operatorname{poly}(d)))-DP algorithm for selection from dd candidates using aggregation queries alone requires Ω(d)\Omega(\sqrt{d}) samples.

The main advantage of this lower bound over most existing lower bounds for selection in restricted models is that we allow algorithms that use queries adaptively. Adaptivity is crucial for implementing most standard ML algorithms and is known to be necessary for some learning problems [25]. We prove this result specifically for aggregation with Gaussian noise addition, with the privacy guarantee derived by composition of the guarantees for individual queries (Theorem 4.4). This implies that our lower bound applies to any API with a comparable privacy-utility trade-off, which is known to be asymptotically optimal for L2L2 error. We observe that such an aggregation oracle can be implemented via distributed noise addition [28] while satisfying weaker privacy guarantees. We then prove a lower bound for such protocols using the information-theoretic techniques from [10, 33].

To address these limitations, we propose adding a new Sparse Vector Technique (SVT) primitive. This primitive implements a special case of the sparse vector technique of [31], and suffices to implement a large class of private algorithms. By integrating SVT as a fundamental primitive, our approach expands the expressive power of DP APIs, improves accuracy guarantees, and supports a wider range of applications.

Informally, the SVT primitive implements the AboveThreshold subroutine for additive queries. We first formally define the SVT primitive. This technique is designed to privately process a potentially long sequence of queries by revealing information only about those whose true values exceed a specified threshold. A key innovation of SVT is that by careful correlation of the noise, the incurred privacy cost grows with the number of initialized SVT streams, and is independent of the number of queries issued. In our proposed primitive, each query is restricted to be a sum of bounded contributions from individual users. These are often referred to as additive or counting queries in the context of SVT, and decomposable score functions in the context of selection. Given nn users with data points x1,…,xn∈Xx_1,\ldots,x_n \in\mathcal{X}, a query is specified by a function qj:X→[0,1]q_j:\mathcal{X}\to[0,1] and a threshold τj\tau_j. Up to noise, the query asks if ∑i=1nqj(xi)≥τj\sum_{i=1}^{n} q_j(x_i)\ge\tau_j, and a Yes answer closes the current stream.1 Because SVT needs to be stateful, we view this functionality in an object that can be created once and queried multiple times with different (qj,τj)(q_j,\tau_j) values chosen potentially in an online fashion. As in SVT, the API ensures that No answers do not incur an additional per-query cost, and each query is correctly answered up to a small additive error.

This primitive has the advantage of simplicity: each query is similar to an aggregation query with one additional threshold parameter. This simplicity allows for efficient and modular implementations of this primitive. While the precise implementation will vary with the trust model, we discuss several options in § 5. At the same time, we show that this primitive is quite powerful. SVT by itself has several applications and one can naturally implement any algorithm that builds on SVT for additive queries in this model (e.g., Private Multiplicative Weights [46]). We next argue that selection (the task solved by the exponential mechanism [56]) can be implemented using the SVT API for any decomposable score function. Recall that given a dataset (x1,…,xn)∈Xn(x_1,\ldots,x_n) \in\mathcal{X}^n, and dd score functions s1,…,sd:Xn→Rs_1,\ldots,s_d:\mathcal{X}^n \to\mathbb{R}, the goal is to select the candidate k∈[d]k \in[d] that (approximately) maximizes the score. We restrict ourselves to additive score functions of the form sj(x1,…,xn)=∑i=1nfj(xi)s_j(x_1,\ldots,x_n)=\sum_{i=1}^n f_j(x_i) for some fj:X→[0,1]f_j:\mathcal{X}\to[0,1]. We say an output candidate jj achieves additive error α\alpha if

sj(x1,…,xn)≥max⁡k∈[d]sk(x1,…,xn)−α.s_j(x_1,\ldots,x_n) \ge\max_{k\in[d]} s_k(x_1,\ldots,x_n)-\alpha.

The reader may immediately notice that if one knew the target value max⁡k∈[d]sk(x1,…,xn)\max_{k\in[d]} s_k(x_1,\ldots,x_n), then a sequential pass over the dd score functions with that target value minus the SVT accuracy margin as a threshold yields a candidate with additive error at most twice that margin. This gives a mechanism with error O(log⁡d/ε)O(\log d/\varepsilon) that matches that of the exponential mechanism, and is known to be optimal. Without knowing the target value, the natural approach is to start with a large guess for this threshold, and gradually reduce it. This algorithm (Algorithm 7) yields the optimal error with O(d(n+1))O(d(n+1)) SVT queries.

It is easy to see that any algorithm must make Ω(d)\Omega(d) queries. When nn is large, the algorithm above incurs significant overhead in the number of queries. This leads to the natural question of whether one can reduce the number of queries to be closer to linear in dd. We show that this is indeed possible: we give a new algorithm that achieves the optimal O(log⁡d/ε)O(\log d/\varepsilon) additive error (when nn is polynomial in dd) and makes only O(dlog⁡∗d)O(d\log^* d) queries to the SVT API in expectation.

Theorem 2.2. Let ε∈(0,1]\varepsilon\in(0,1]. There exists an ε\varepsilon-pure DP protocol that solves the selection problem for additive scores up to expected additive error O(log⁡(dn)ε)O\left(\frac{\log(dn)}{\varepsilon}\right), using O(dlog⁡∗n+log⁡3n)O(d\log^* n+\log^3 n) oracle queries to the SVT API in expectation.

When the number of users nn is upper bounded by a polynomial in dd, the error of our protocol matches the optimal additive error of O(log⁡d/ε)O(\log d/\varepsilon) achievable in the central model of privacy, and the query complexity matches the dd lower bound up to an O(log⁡∗d)O(\log^* d) factor. We then show a number of applications of Theorem 2.2, specifically, to FpF_p losses, heavy hitters with categories, multiplicative weights with the exponential mechanism, and sparse mean estimation.

Our lower and upper bounds for selection extend to other natural tasks. Combined with known results for the shuffle model, our new upper bounds in the SVT model, and our lower bounds in the aggregation model emphasize the value of the SVT primitive. As we show in Figure 1, our new API allows for accurate selection, where aggregation and shuffle models must incur large errors.

Comparison table of additive error for SecAgg, Shuffle DP, SVT, and Central DP

Figure 1. Comparison of the additive error achievable for the different APIs in the federated setting, up to constant factors, for nn users. In the aggregation row each user holds a vector of ℓ2\ell_2 norm at most 1 and the error is the ℓ2\ell_2 error of the sum. In the selection row each user holds scores in [0,1]d[0,1]^d and the error is the additive error in the sum score; the entry d/ε\sqrt{d}/\varepsilon indicates that error o(n)o(n) is not achievable unless n≥Ω(d/ε)n \ge\Omega(\sqrt{d}/\varepsilon). The entries for SVT and central DP are upper bounds (ε\varepsilon-DP, Theorem 2.2 for SVT with nn polynomial in dd). The entries for SecAgg and shuffle DP are lower bounds: for algorithms that access the data through an aggregation API (Theorem 4.4), and for robust or single-round shuffle protocols (Theorem 3.3 and Theorem 3.4).

Other related work. Our lower bounds for aggregation APIs are most closely related to statistical query (SQ) lower bounds in learning theory [6, 40]. An SQ oracle is an oracle that for a query qq and data distribution PP is guaranteed to return a value within some prescribed tolerance τ\tau of the expectation Ex∼P[q(x)]\mathbb{E}_{x\sim P}[q(x)] (the returned value may be chosen arbitrarily by the oracle). It is known that learning a parity function over kk coordinates requires Ω(2kτ2)\Omega(2^k\tau^2) statistical queries of tolerance τ\tau (e.g. [37]). Learning a parity function reduces to selection in dimension 2k2^k and thus this also gives a lower bound for selection. These lower bounds do not apply to our setting as we answer queries relative to a given dataset (and not the distribution).

SQ lower bounds are known to imply lower bounds for the local model of privacy with a pure-DP randomizer [50]. This reduction is also based on a simulation of a randomizer using an SQ oracle and, as a result, does not imply any lower bounds for the setting where the number of queries is comparable to dd. A direct lower bound of Ω(d/ε2)\Omega(d/\varepsilon^2) samples for ε\varepsilon-DP local non-interactive protocols was given by [27]. A similar lower bound on non-interactive local-DP protocols was given by [64] for sparse Boolean mean estimation. More recently, a lower bound of d/ε2d/\varepsilon^2 for sparse Gaussian mean estimation in the local DP model that allows interactivity and (ε,δ)(\varepsilon,\delta) and 1-Renyi-DP (or KL-private) randomizers was given by [33].

Several recent works [24, 20, 11] provide lower bounds for private selection in variants of the multi-message shuffle model. All of these apply only to non-interactive (or one-round shuffling) settings. In fact, [11] show that a two-round multi-message protocol can simulate arbitrary secure multi-party protocols. The lower bound of [24] is the same as ours, Ω(d/ε)\Omega(\sqrt{d}/\varepsilon), and is based on somewhat related ideas. The lower bounds in [20, 11] are of the form d/md/m, where mm is the number of messages sent by each user, and thus are not directly comparable to ours.

The question of implementing selection using simpler APIs has also been raised as an open question for low-sensitivity queries in [61], and recent work [51] has shown nearly-optimal algorithms for that model. Arbitrary low-sensitivity queries can, however, be challenging to implement, and hence we focus on additive queries in this work.

Preliminaries

We use the notation [n][n] for a positive integer n>0n > 0 to denote the set {1,2,…,n}\{1,2,\ldots,n\}. For functions f(n)f(n), g(n)g(n), we sometimes use the notation f(n)⪯g(n)f(n) \preceq g(n) in conjunction with f(n)=O(g(n))f(n) = O(g(n)), i.e., that there exists a constant C≥0C \ge0 such that f(x)≤C⋅g(x)f(x) \le C \cdot g(x) for all x≥nx \ge n for a sufficiently large nn.

Definition 3.1 (Differential privacy [30]). Let MM be a randomized algorithm mapping a dataset x∈Xn\mathbf{x} \in\mathcal{X}^n to a range R\mathcal{R}. We say two datasets x,x′\mathbf{x},\mathbf{x}' are neighboring if xi=xi′x_i = x'_i for all but one of the nn coordinates. The mechanism MM is (ε,δ)(\varepsilon,\delta)-differentially private if for any pair of neighboring datasets x,x′\mathbf{x},\mathbf{x}', and for any event E⊆RE \subseteq\mathcal{R},

Pr⁡[M(x)∈E]≤eε⋅Pr⁡[M(x′)∈E]+δ.\Pr[M(\mathbf{x}) \in E] \le e^\varepsilon\cdot\Pr[M(\mathbf{x}') \in E] + \delta.

When an algorithm is (ε,0)(\varepsilon,0)-differentially private, we often call it ε\varepsilon-differentially private.

Shuffle model. In the shuffle model, each individual user first randomizes their own data into one or more messages. These messages are then sent to a secure shuffler, which aggregates and randomly permutes all user messages. The shuffle model considers an attacker who only sees the collection of messages after the permutation and thus, the set of shuffled messages must satisfy differential privacy. Equivalently, an attacker can only observe the histogram of the messages. Formally, we have the following definition:

Definition 3.2 (Shuffle model of differential privacy). In the shuffle model of privacy, a protocol Π\Pi consists of three randomized algorithms:

  • A randomizer ΠR:X→Y∗\Pi_{\mathrm{R}} : \mathcal{X} \to\mathcal{Y}^{*} that maps data to vectors, possibly of variable length, which denotes the number of messages sent. The protocol is said to be single-message if the probability of sending a single message is 11 on all inputs; otherwise it is said to be multi-message.

  • A shuffler ΠS:Y∗→Y∗\Pi_{\mathrm{S}} : \mathcal{Y}^{*} \to\mathcal{Y}^{*} that applies a uniformly random permutation to all messages.

  • An analyzer ΠA:Y∗→O\Pi_{\mathrm{A}} : \mathcal{Y}^{*} \to\mathcal{O} that performs computation on a set of messages (after permutation).

Since the shuffler is the same across all protocols, we use Π=(ΠR,ΠA)\Pi= (\Pi_{\mathrm{R}}, \Pi_{\mathrm{A}}) to denote each shuffle protocol Π\Pi, so that on an input x∈Xnx \in\mathcal{X}^{n}, the output is Π(x)=ΠA(ΠS(ΠR(x1),…,ΠR(xn)))\Pi(x) = \Pi_{\mathrm{A}}(\Pi_{\mathrm{S}}(\Pi_{\mathrm{R}}(x_{1}), \ldots, \Pi_{\mathrm{R}}(x_{n}))). Hence, we denote the output of the shuffler by (ΠS∘ΠRn)(x):=ΠS(ΠR(x1),…,ΠR(xn))(\Pi_{\mathrm{S}} \circ\Pi_{\mathrm{R}}^{n})(x) := \Pi_{\mathrm{S}}(\Pi_{\mathrm{R}}(x_{1}), \ldots, \Pi_{\mathrm{R}}(x_{n})).

We remark on two existing lower bounds for selection in the shuffle model of privacy. We first recall the following lower bound by [20]:

References

  1. [1][ACG+16] Martin Abadi, Andy Chu, Ian Goodfellow, H. Brendan McMahan, Ilya Mironov, Kunal Talwar, and Li Zhang. Deep learning with differential privacy. In Proceedings of the 2016 ACM SIGSAC Conference on Computer and Communications Security, CCS ’16, page 308–318, New York, NY, USA, 2016. Association for Computing Machinery. 2DOI
  2. [2][BBCC+25] Borja Balle, James Bell-Clark, Albert Cheu, Adria Gascon, Jonathan Katz, Mariana Raykova, Philipp Schoppmann, and Thomas Steinke. Hash-prune-invert: Improved differentially private heavy-hitter detection in the two-server model. In 2025 IEEE Symposium on Security and Privacy (SP), pages 2903–2918, 2025. 11DOI
  3. [3][BDG+13] Gilles Barthe, George Danezis, Benjamin Grégoire, César Kunz, and Santiago Zanella-Béguelin. Verified computational differential privacy with applications to smart metering. In 2013 IEEE 26th Computer Security Foundations Symposium, pages 287–301, 2013. 2DOI
  4. [4][BEM+17] Andrea Bittau, Úlfar Erlingsson, Petros Maniatis, Ilya Mironov, Ananth Raghunathan, David Lie, Mitch Rudominer, Ushasree Kode, Julien Tinnés, and Bernhard Seefeld. Prochlo: Strong privacy for analytics in the crowd. In Proceedings of the 26th Symposium on Operating Systems Principles, pages 441–459, 2017. 2DOI
  5. [5]Gilles Barthe, Noémie Fong, Marco Gaboardi, Benjamin Grégoire, Justin Hsu, and Pierre-Yves Strub. Advanced probabilistic couplings for differential privacy. In Proceedings of the ACM SIGSAC Conference on Computer and Communications Security, pages 55–67, 2016. 2DOI
  6. [6]Avrim Blum, Merrick L. Furst, Jeffrey C. Jackson, Michael J. Kearns, Yishay Mansour, and Steven Rudich. Weakly learning DNF and characterizing statistical query learning using fourier analysis. In Proceedings of the Twenty-Sixth Annual ACM Symposium on Theory of Computing, pages 253–262, 1994. 4
  7. [7]Gilles Barthe, Marco Gaboardi, Emilio Jesús Gallego Arias, Justin Hsu, César Kunz, and Pierre-Yves Strub. Proving differential privacy in hoare logic. In IEEE 27th Computer Security Foundations Symposium, CSF, pages 411–424, 2014. 2DOI
  8. [8]Benjamin Bichsel, Timon Gehr, Dana Drachsler-Cohen, Petar Tsankov, and Martin T. Vechev. Dp-finder: Finding differential privacy violations by sampling and optimization. In Proceedings of the 2018 ACM SIGSAC Conference on Computer and Communications Security, CCS, pages 508–524, 2018. 2
  9. [9]Gilles Barthe, Marco Gaboardi, Benjamin Grégoire, Justin Hsu, and Pierre-Yves Strub. Proving differential privacy via probabilistic couplings. In Proceedings of the 31st Annual ACM/IEEE Symposium on Logic in Computer Science, LICS, pages 749–758, 2016. 2DOI
  10. [10]Mark Braverman, Ankit Garg, Tengyu Ma, Huy L Nguyen, and David P Woodruff. Communication lower bounds for statistical estimation problems via a distributed data processing inequality. In Proceedings of the forty-eighth annual ACM symposium on Theory of Computing, pages 1011–1020, 2016. 3, 8, 34, 35arxiv.org/abs/1506.07216
  11. [11]Amos Beimel, Iftach Haitner, Kobbi Nissim, and Uri Stemmer. On the round complexity of the shuffle model. In Theory of Cryptography Conference, pages 683–712. Springer, 2020. 5arxiv.org/abs/2009.13510
  12. [12]Keith Bonawitz, Vladimir Ivanov, Ben Kreuter, Antonio Marcedone, H. Brendan McMahan, Sarvar Patel, Daniel Ramage, Aaron Segal, and Karn Seth. Practical secure aggregation for privacy-preserving machine learning. In Proceedings of the 2017 ACM SIGSAC Conference on Computer and Communications Security, CCS ’17, page 1175–1191, New York, NY, USA, 2017. Association for Computing Machinery. 2DOI
  13. [13]Keith Bonawitz, Vladimir Ivanov, Ben Kreuter, Antonio Marcedone, H Brendan McMahan, Sarvar Patel, Daniel Ramage, Aaron Segal, and Karn Seth. Practical secure aggregation for privacy-preserving machine learning. In proceedings of the 2017 ACM SIGSAC Conference on Computer and Communications Security, pages 1175–1191, 2017. 11DOI
  14. [14]Gilles Barthe and Federico Olmedo. Beyond differential privacy: Composition theorems and relational logic for f-divergences between probabilistic programs. In Automata, Languages, and Programming - 40th International Colloquium, ICALP, Proceedings, Part II, pages 49–60, 2013. 2DOI
  15. [15]Mark Bun and Thomas Steinke. Concentrated differential privacy: Simplifications, extensions, and lower bounds. In Theory of cryptography conference, pages 635–658. Springer, 2016. 7, 8arxiv.org/abs/1605.02065
  16. [16]Raef Bassily, Adam Smith, and Abhradeep Thakurta. Private empirical risk minimization: Efficient algorithms and tight error bounds. In Proceedings of the 2014 IEEE 55th Annual Symposium on Foundations of Computer Science, FOCS ’14, page 464–473, USA, 2014. IEEE Computer Society. 2
  17. [17]Mark Bun, Thomas Steinke, and Jonathan Ullman. Make up your mind: the price of online queries in differential privacy. In Proceedings of the Twenty-Eighth Annual ACM-SIAM Symposium on Discrete Algorithms, SODA ’17, page 1306–1325, USA, 2017. Society for Industrial and Applied Mathematics. 3, 8, 12
  18. [18]Victor Balcer and Salil Vadhan. Differential privacy on finite computers. Journal of Privacy and Confidentiality, 9(2), Sep. 2019. 2arxiv.org/abs/1709.05396
  19. [19]Henry Corrigan-Gibbs and Dan Boneh. Prio: Private, robust, and scalable computation of aggregate statistics. In 14th USENIX Symposium on Networked Systems Design and Implementation, NSDI, pages 259–282, 2017. 10
  20. [20]Lijie Chen, Badih Ghazi, Ravi Kumar, and Pasin Manurangsi. On distributed differential privacy and counting distinct elements. In 12th Innovations in Theoretical Computer Science Conference, ITCS, pages 56:1–56:18, 2021. 3, 5, 6arxiv.org/abs/2009.09604
  21. [21]Clement Canonne, Gautam Kamath, and Thomas Steinke. The discrete gaussian for differential privacy. Journal of Privacy and Confidentiality, 12(1), Jul. 2022. 2DOI
  22. [22]Albert Cheu, Adam D. Smith, Jonathan R. Ullman, David Zeber, and Maxim Zhilyaev. Distributed differential privacy via shuffling. In Advances in Cryptology - EUROCRYPT 2019 - 38th Annual International Conference on the Theory and Applications of Cryptographic Techniques, Proceedings, Part I, pages 375–403, 2019. 2, 3DOI
  23. [23]Thomas M. Cover and Joy A. Thomas. Elements of Information Theory. Wiley, 2 edition, 2006. 34
  24. [24]Albert Cheu and Jonathan R. Ullman. The limits of pan privacy and shuffle privacy for learning and estimation. In STOC ’21: 53rd Annual ACM SIGACT Symposium on Theory of Computing, pages 1081–1094, 2021. 3, 5, 6arxiv.org/abs/2009.08000
  25. [25]Yuval Dagan and Vitaly Feldman. Interaction is necessary for distributed learning with privacy or communication constraints. In Proceedings of the 52nd Annual ACM SIGACT Symposium on Theory of Computing, pages 450–462, 2020. 3arxiv.org/abs/1911.04014
  26. [26]John C. Duchi, Michael I. Jordan, and Martin J. Wainwright. Local privacy and statistical minimax rates. In 2013 IEEE 54th Annual Symposium on Foundations of Computer Science, pages 429–438, 2013. 3
  27. [27]John C Duchi, Michael I Jordan, and Martin J Wainwright. Minimax optimal procedures for locally private estimation. Journal of the American Statistical Association, 113(521):182–201, 2018. 5arxiv.org/abs/1604.02390
  28. [28]Cynthia Dwork, Krishnaram Kenthapadi, Frank McSherry, Ilya Mironov, and Moni Naor. Our data, ourselves: Privacy via distributed noise generation. In Advances in Cryptology - EUROCRYPT 2006, 25th Annual International Conference on the Theory and Applications of Cryptographic Techniques, Proceedings, pages 486–503, 2006.
  29. [30]Cynthia Dwork, Frank McSherry, Kobbi Nissim, and Adam Smith. Calibrating noise to sensitivity in private data analysis. Journal of Privacy and Confidentiality, 7(3):17–51, 2017.
  30. [31]Cynthia Dwork, Moni Naor, Omer Reingold, Guy N. Rothblum, and Salil P. Vadhan. On the complexity of differentially private data release: efficient algorithms and hardness results. In Proceedings of the 41st Annual ACM Symposium on Theory of Computing, STOC, pages 381–390, 2009.
  31. [32]Cynthia Dwork, Aaron Roth, et al. The algorithmic foundations of differential privacy. Foundations and trends® in theoretical computer science, 9(3–4):211–407, 2014.
  32. [33]John Duchi and Ryan Rogers. Lower bounds for locally private estimation via communication complexity. In Conference on Learning Theory, pages 1161–1191. PMLR, 2019.arxiv.org/abs/1902.00582
  33. [34]Úlfar Erlingsson, Vitaly Feldman, Ilya Mironov, Ananth Raghunathan, Kunal Talwar, and Abhradeep Thakurta. Amplification by shuffling: From local to central differential privacy via anonymity. In Proceedings of the Thirtieth Annual ACM-SIAM Symposium on Discrete Algorithms, SODA, pages 2468–2479, 2019.arxiv.org/abs/1811.12469
  34. [35]Alexandre V. Evfimievski, Johannes Gehrke, and Ramakrishnan Srikant. Limiting privacy breaches in privacy preserving data mining. In Proceedings of the Twenty-Second ACM SIGACT-SIGMOD-SIGART Symposium on Principles of Database Systems, pages 211–222, 2003.
  35. [37]Vitaly Feldman. Open problem: The statistical query complexity of learning sparse halfspaces. In Proceedings of The 27th Conference on Learning Theory, COLT, pages 1283–1289, 2014.
  36. [40]Vitaly Feldman, Elena Grigorescu, Lev Reyzin, Santosh S Vempala, and Ying Xiao. Statistical algorithms and a lower bound for detecting planted cliques. Journal of the ACM (JACM), 64(2):1–37, 2017. 4
  37. [41]Vitaly Feldman and Thomas Steinke. Generalization for adaptively-chosen estimators via stable median. In Conference on learning theory, pages 728–757. PMLR, 2017. 37arxiv.org/abs/1706.05069
  38. [42]Vitaly Feldman and Tijana Zrnic. Individual privacy accounting via a renyi filter. Advances in Neural Information Processing Systems, 34:28080–28091, 2021. 7arxiv.org/abs/2008.11193
  39. [43]Ji Guan, Wang Fang, Mingyu Huang, and Mingsheng Ying. Detecting violations of differential privacy for quantum algorithms. In Proceedings of the 2023 ACM SIGSAC Conference on Computer and Communications Security, CCS, pages 2277–2291, 2023. 2DOI
  40. [44]Marco Gaboardi, Andreas Haeberlen, Justin Hsu, Arjun Narayan, and Benjamin C. Pierce. Linear dependent types for differential privacy. In The 40th Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, POPL, pages 357–370, 2013. 2
  41. [45]Moritz Hardt, Katrina Ligett, and Frank McSherry. A simple and practical algorithm for differentially private data release. In Advances in Neural Information Processing Systems 25: 26th Annual Conference on Neural Information Processing Systems 2012. Proceedings, pages 2348–2356, 2012. 24, 25, 37, 38
  42. [46]Moritz Hardt and Guy N. Rothblum. A multiplicative weights mechanism for privacy-preserving data analysis. In 2010 IEEE 51st Annual Symposium on Foundations of Computer Science, pages 61–70, 2010. 4DOI
  43. [47]T. S. Jayram. Hellinger strikes back: A note on the multi-party information complexity of and. In Proceedings of the 12th International Workshop and 13th International Workshop on Approximation, Randomization, and Combinatorial Optimization. Algorithms and Techniques, APPROX ’09 / RANDOM ’09, page 562–573. Springer-Verlag, 2009. 34DOI
  44. [49]Matthew Joseph, Jieming Mao, Seth Neel, and Aaron Roth. The role of interactivity in local differential privacy. In 2019 IEEE 60th Annual Symposium on Foundations of Computer Science (FOCS), pages 94–105. IEEE, 2019. 7arxiv.org/abs/1904.03564
  45. [50]Shiva Prasad Kasiviswanathan, Homin K. Lee, Kobbi Nissim, Sofya Raskhodnikova, and Adam D. Smith. What can we learn privately? SIAM J. Comput., 40(3):793–826, 2011. 2, 4
  46. [51]Ethan Leeman and Pasin Manurangsi. Nearly-optimal private selection via gaussian mechanism, 2025. 5arxiv.org/abs/2511.06871
  47. [52]Xin Lyu. Composition theorems for interactive differential privacy. Advances in Neural Information Processing Systems, 35:9700–9712, 2022. 10
  48. [53]Frank McSherry. Privacy integrated queries: an extensible platform for privacy-preserving data analysis. Commun. ACM, 53(9):89–97, 2010. 2
  49. [54]Ilya Mironov. On significance of the least significant bits for differential privacy. In the ACM Conference on Computer and Communications Security, CCS’12, pages 650–661, 2012. 2DOI
  50. [55]Ilya Mironov. Rényi differential privacy. In 30th IEEE Computer Security Foundations Symposium, CSF, pages 263–275, 2017. 2, 7DOI
  51. [56]Frank McSherry and Kunal Talwar. Mechanism design via differential privacy. In 48th Annual IEEE Symposium on Foundations of Computer Science, FOCS, Proceedings, pages 94–103, 2007. 4, 25
  52. [58]Edo Roth, Daniel Noble, Brett Hemenway Falk, and Andreas Haeberlen. Honeycrisp: Large-scale differentially private aggregation without a trusted core. In Proceedings of the 27th ACM Symposium on Operating Systems Principles, SOSP ’19, page 196–210, New York, NY, USA, 2019. Association for Computing Machinery. 2
  53. [59]Indrajit Roy, Srinath T. V. Setty, Ann Kilzer, Vitaly Shmatikov, and Emmett Witchel. Airavat: Security and privacy for mapreduce. In Proceedings of the 7th USENIX Symposium on Networked Systems Design and Implementation, NSDI, pages 297–312, 2010. 2
  54. [60]Edo Roth, Hengchu Zhang, Andreas Haeberlen, and Benjamin C. Pierce. Orchard: Differentially private analytics at scale. In 14th USENIX Symposium on Operating Systems Design and Implementation (OSDI 20), pages 1065–1081. USENIX Association, November 2020. 2
  55. [61]Thomas Steinke. Open problem: Selection via low-sensitivity queries. DifferentialPrivacy.org, 05 2025. https://differentialprivacy.org/open-problem-selection/. 5
  56. [62]The OpenDP Team. The opendp white paper, 2020. 2
  57. [64]Jonathan Ullman. Tight lower bounds for locally differentially private selection. arXiv preprint arXiv:1802.02638, 2018. 5
  58. [65]Salil Vadhan and Tianhao Wang. Concurrent composition of differential privacy. In Theory of Cryptography Conference, pages 582–604. Springer, 2021. 10
  59. [66]Salil P. Vadhan and Wanrong Zhang. Concurrent composition theorems for differential privacy. In Proceedings of the 55th Annual ACM Symposium on Theory of Computing, STOC, pages 507–519, 2023. 10DOI
  60. [67]Stanley L Warner. Randomized response: A survey technique for eliminating evasive answer bias. Journal of the American statistical association, 60(309):63–69, 1965. 2pubmed.ncbi.nlm.nih.gov/12261830
  61. [68]Royce J. Wilson, Celia Yuxin Zhang, William Lam, Damien Desfontaines, Daniel Simmons-Marengo, and Bryant Gipson. Differentially private SQL with bounded user contribution. Proc. Priv. Enhancing Technol., 2020(2):230–250, 2020. 2arxiv.org/abs/1909.01917
  62. [69]Danfeng Zhang and Daniel Kifer. Lightdp: towards automating differential privacy proofs. In Proceedings of the 44th ACM SIGPLAN Symposium on Principles of Programming Languages, POPL, pages 888–901, 2017. 2

Paper details

vlnc:W_ncvbjvg7
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 0

downloads · 2

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

AI tools

View statement
Looking for related papers…
Contents