Abstract 1 Introduction 2 Preliminaries 3 Simple Mechanism for Privately Releasing the MST 4 Lower Bounds for MST 5 Finding a Large Set of Dissimilar Trees 6 Universal Near-Optimality via the Exponential Mechanism References Appendix A Exponential Mechanism

Near-Universally-Optimal Differentially Private
Minimum Spanning Trees

Richard Hladík ORCID ETH Zurich, Switzerland Jakub Tětek ORCID INSAIT, Sofia University “St. Kliment Ohridski”, Bulgaria
Abstract

Devising mechanisms with good beyond-worst-case input-dependent performance has been an important focus of differential privacy, with techniques such as smooth sensitivity, propose-test-release, or inverse sensitivity mechanism being developed to achieve this goal. This makes it very natural to use the notion of universal optimality in differential privacy. Universal optimality is a strong instance-specific optimality guarantee for problems on weighted graphs, which roughly states that for any fixed underlying (unweighted) graph, the algorithm is optimal in the worst-case sense, with respect to the possible setting of the edge weights.

In this paper, we give the first such result in differential privacy. Namely, we prove that a simple differentially private mechanism for approximately releasing the minimum spanning tree is near-optimal in the sense of universal optimality for the 1 neighbor relation. Previously, it was only known that this mechanism is nearly optimal in the worst case. We then focus on the neighbor relation, for which the described mechanism is not optimal. We show that one may implement the exponential mechanism for MST in polynomial time, and that this results in universal near-optimality for both the 1 and the neighbor relations.

Keywords and phrases:
differential privacy, universal optimality, minimum spanning trees
Funding:
Richard Hladík: Supported in part by the European Research Council (ERC) under the European Union’s Horizon 2020 Research and Innovation Programme (grant agreement No. 949272).
Copyright and License:
[Uncaptioned image] © Richard Hladík and Jakub Tětek; licensed under Creative Commons License CC-BY 4.0
2012 ACM Subject Classification:
Security and privacy Privacy-preserving protocols
; Mathematics of computing Graph algorithms
Related Version:
Full Version: https://arxiv.org/abs/2404.15035
Acknowledgements:
We would like to thank Rasmus Pagh for helpful discussions and hosting Richard at the University of Copenhagen. We would like to thank Bernhard Haeupler for helpful discussions. Jakub worked on this paper while affiliated with BARC, University of Copenhagen. Richard partially worked on this paper while visiting BARC, University of Copenhagen.
Funding:
Partially funded by the Ministry of Education and Science of Bulgaria’s support for INSAIT as part of the Bulgarian National Roadmap for Research Infrastructure. Partially supported by the VILLUM Foundation grants 54451 and 16582.
Editors:
Mark Bun

1 Introduction

The minimum spanning tree (MST) problem is one of the classic combinatorial problems, making the release of an MST a fundamental question in differential privacy. Unfortunately, if the edge set is private, this problem cannot be solved, as it would require us to release a subset of the edges (note that we want to release the edges of the MST and not just their total weight). It is therefore natural to consider this problem in the (standard) setting where the underlying unweighted graph is public, but the weights are private.

The following simple near-linear-time mechanism has been proposed for this problem [26]: add Laplacian noise to the edge weights, making them private, then find the MST with the noisy weights. At the same time, the author shows that this mechanism is near-optimal in the worst case.

In this paper, we prove a much stronger optimality claim for this algorithm, namely that it is universally optimal up to a logarithmic factor for the 1 neighbor relation (i.e., two graphs on the same edge set are neighboring if the edge weights differ by 1 in the 1 norm). An algorithm (or differentially private mechanism) that works on weighted graphs is said to be universally optimal, if for any fixed underlying unweighted graph G, it is worst-case optimal with respect to the possible settings of edge weights 𝐰. That is, if we write a weighted graph G~=(G,𝐰), universal optimality states that for any fixed G, we are worst-case optimal w.r.t. 𝐰. Standard worst-case optimality, on the other hand, is worst-case w.r.t. both 𝐰 and G.

We then focus on differential privacy with the neighbor relation (defined analogously to the 1 neighbor relation), for which the above algorithm is not universally optimal. We instead prove that one may implement the exponential mechanism for MST in polynomial time by relying on a known sampling result [6]. We prove that this more complicated and somewhat slower 𝒪(nω)-time algorithm does achieve universal optimality up to a logarithmic factor for both the 1 and the neighbor relations. For the neighbor relation, this improves upon the PAMST algorithm of Pinot [23] which is only known to be near-optimal in the worst-case sense.

Our results are the first to prove the universal optimality of a differentially private mechanism.111The name universal optimality unfortunately has different meaning in different contexts. There are several results that are universally optimal with one of these different meanings, as we discuss in Section 1.2. We stick with the meaning commonly used in distributed algorithms. This is despite the fact that previous work in differential privacy has put a lot of emphasis on instance-specific performance guarantees: smooth sensitivity, propose-test-release, privately bounding local sensitivity, and inverse sensitivity mechanism are all examples of this trend. This makes it very natural to focus on universal optimality, perhaps making it somewhat surprising that universal optimality is not already being commonly used in differential privacy.

As a side note, we also prove that the above-mentioned linear-time algorithm is optimal up to a constant factor in the worst-case sense. This improves upon previous results which had a logarithmic gap [26]. Similarly, we prove that the exponential mechanism is for MST worst-case optimal up to a constant factor for both the 1 and the neighbor relations.

1.1 Technical Overview

In this section, we briefly discuss the intuition and techniques behind our results. Here, we focus mostly on the 1 neighbor relation and universal near-optimality. The lower bound arguments for and the worst-case optimality are similar. The comparison between ours and previous results is summarized in Table 1.

Our lower and upper bounds rely on the properties of the set 𝒯(G) of all spanning trees of a given (unweighted) graph G. We define a Hamming-like metric dH in this space, defined as dH(T1,T2)=|T1T2|. It turns out that the diameter D of 𝒯(G) with respect to dH is a natural parameter that determines the “hardness” of G. Namely, we show an Ω(D/ε) lower bound and an 𝒪(Dlogn/ε) upper bound on the expected error of the optimal ε-differentially private algorithm.

Upper bound

In Section 3, we use the diameter D to obtain a sharper analysis of the Laplace mechanism of Sealfon [26]. The mechanism is very simple: add Laplacian noise to every edge, then return the MST with respect to the noisy weights. Its standard analysis uses the fact that with high probability, the noise on every edge is 𝒪(logn/ε), and thus the total error of the spanning tree returned is 𝒪(nlogn/ε). Our improvement follows from the fact that the returned spanning tree differs from the MST in at most 2D edges, and thus the total error accumulated is actually only 𝒪(Dlogn/ε).

Lower bound

The most technically interesting part of this paper is our lower bound in Section 4. We have a fixed underlying graph G and for any ε-differentially private mechanism, we want to find a weight assignment 𝐰 on which the error will be large. Our lower bound builds on a general packing-based lower bound for differentially private algorithms, which we briefly paraphrase in the language of MSTs and universal optimality: Given a set 𝒲 of weight vectors and a parameter x0, define for each 𝐰𝒲 the set 𝐰 of spanning trees that are x-light for this 𝐰, i.e., that are heavier than the MST by at most x. Moreover, assume that the sets 𝐰 are pairwise disjoint, that is, each spanning tree is x-light with respect to at most one weight vector in 𝒲. Then the expected error of any ε-differentially private algorithm is Ω(xlog|𝒲|/(rε)) on at least one weight assignment 𝐰𝒲, where r is the diameter of 𝒲 in the metric induced by the neighbor relation .

Intuitively speaking, we have a set 𝒲 of weight assignments and for each of them, we consider a ball of outputs that are “good” in the sense that their error is “small” (with respect to x) for this input. Our goal is to find a large collection 𝒲 of weights that are “close” (i.e., r is small), but which induce disjoint balls that are “wide” (i.e., we can set x to be large).

Reduction to finding many dissimilar spanning trees

The problem of finding 𝒲 that maximizes the expression xlog|𝒲|/(rε) is somewhat complicated by the fact that we have a trade-off between |𝒲|, x and r. In order to solve this problem, we first show how to reduce it to a combinatorial problem of finding a large set of dissimilar spanning trees.

The main idea of the reduction is as follows: assume we have S𝒯(G) such that every two T1,T2 in S have dH(T1,T2)>d. We construct 𝒲 by, for each TS, creating a weight vector 𝐰T by defining 𝐰T(e)=0 if eT and 1 otherwise. Now the crucial observation is that 𝐰T()=dH(T,). That is, for any T, the weight of T under the weight vector 𝐰T is exactly the Hamming distance between T and T. One can then verify that for every T𝒯(G), there is at most one weight 𝐰T𝒲 under which its weight is at most d/2, as otherwise we would, by the triangle inequality, for some T1,T2S have that dH(T1,T2)dH(T1,T)+dH(T2,T)d, which would be a contradiction with the definition of d. Therefore, we can set x as large as d/2 while still ensuring the disjointness property of all 𝐰 required by the original lower bound.

An upper bound of r2D can be argued as follows: We have that any two spanning trees differ in 2D edges. Combined with having zero-one weights, any two spanning trees’ weight vectors 𝐰T thus also have 1-distance at most 2D, and thus r2D.

Using these ideas, we have reduced the original problem to the problem of finding a large set S of spanning trees that is sparse in the sense that no two spanning trees in S are similar. More specifically, we have reduced the original problem to the problem of finding a set S of spanning trees which maximizes log|S|/d.

How to find many dissimilar spanning trees?

Finally, the problem of finding a large, yet sparse S, is reducible to a standard problem: We show that there are always at least 2D spanning trees, and the problem of finding a sparse subset among them can be reduced to finding a binary code of length D and minimum Hamming distance Ω(D) that has 2Ω(D) many codewords. Such a code exists by the Gilbert–Varshamov bound [14, 28]. The S that we get from this reduction then allows us to prove an Ω(D/ε) lower bound on the expected error, which nearly matches the 𝒪(Dlogn/ε) upper bound mentioned above.

1.2 Related Work

Table 1: Summary of our results. Recall that D is the diameter of the space 𝒯(G) of spanning trees of G, as defined in Section 2.2.
neighborhood on a fixed graph topology worst-case previous work (worst-case)
lower bound upper bound lower and upper bound lower bound upper bound reference
1 Ω(D/ε) 𝒪(Dlogn/ε) Θ(nlogn/ε) Ω(n/ε) 𝒪(nlogn/ε) [26]
Ω(D2/ε) 𝒪(D2logn/ε) Θ(n2logn/ε) 𝒪(n2logn/ε) [23]

Differentially private minimum spanning trees

The problem of privately releasing the MST in the “public graph, private weights” setting was first studied by Sealfon [26]. The author shows a worst-case lower bound of Ω(n/ε) on the expected error for the 1 neighbor relation, proposes a simple mechanism based on adding Laplacian noise to all weights and calculating the MST with respect to the noisy weights, and proves that it is worst-case optimal up to an 𝒪(logn) factor. In Sections 3 and 4, we show that this mechanism is in fact worst-case optimal up to a constant factor and also universally optimal up to an 𝒪(logn) factor.

Pinot [23] gives a mechanism for the neighbor relation by running a noisy version of the Jarník-Prim algorithm that, in each step, selects the edge to be included in the tree by running the exponential mechanism. It has an 𝒪(n2logn/ε) expected error, which, by our results from Section 4, is worst-case optimal. However, the analysis does not seem to be easily modifiable to show universal optimality. We remark that the author claims an expected error of 𝒪(n2logn/(mε)), but this is only true if one normalizes all weights by 1/m.

We also note that releasing the weight of the minimum spanning tree is easy. One may easily show that the global sensitivity is 1 (with 1) or n1 (with ), allowing us to simply find the MST and release its weight using the Laplace mechanism. In their work on smooth sensitivity, Nissim, Raskhodnikova, and Smith [21] consider the problem of privately releasing the weight of the MST in a slightly different setting where the weights are bounded and neighboring datasets differ by changing the weight of one edge.

Other differential privacy notions on graphs

The notion of privacy used in this work was introduced by Sealfon [26] and was since used widely [4, 23, 24, 5, 10, 22]. To paraphrase a real-world motivation, the graph may represent a city’s (publicly known) metro network, with edge weights representing how busy each line is. User’s commute data is private information which contributes to the edge weights and should be protected.222Based on what specific data are stored for each user, this example motivates both the 1 and neighbor relation. Other common privacy notions include edge differential privacy and node differential privacy [18], where the graph itself is unweighted and private, and two graphs G and G are neighboring if one can be obtained from the other by deleting an edge (for edge privacy) or a node and all its adjacent edges (for node privacy).

Instance-optimality in differential privacy

The notion of universal optimality is closely linked to that of instance optimality, which states that our algorithm is “as good as any mechanism could be” on every single instance. Universal optimality can then be seen as a combination of instance-optimality w.r.t. the underlying graph and worst-case optimality w.r.t. the edge weights.

In the last few years, several instance-optimality results have been proven in differential privacy [19, 3, 7, 1]. We highlight here Huang, Liang, and Yi [19] which give an instance-optimal differentially private mechanism for releasing the mean. We also highlight Asi and Duchi [1] who introduce the inverse sensitivity mechanism, and give instance-optimality results for mean estimation, performing linear regression, and the principal component analysis.

It should be noted that there are subtleties in the precise definitions of instance optimality that these papers use. The reason is that under the definition of instance-optimality that is commonly used in other areas, often no instance-optimal mechanism exists in differential privacy for trivial reasons. Therefore, the precise definitions used in the mentioned papers differ somewhat.

Issues with nomenclature

The name “universal optimality” has unfortunately been used to mean different things in different contexts. Throughout this paper, we use universal optimality in the sense in which it is commonly used in distributed algorithms [17]. It should be noted that there have been several works in differential privacy that use the name “universal optimality” to denote completely unrelated concepts [13, 11]. Namely, these papers use the name universal optimality in a Bayesian setting, where universal optimality states that a given mechanism is optimal no matter the prior. This is a completely unrelated notion to what we consider in this paper.

Universal optimality

The notion of universal optimality started in distributed algorithms where multiple classic combinatorial problems are now known to have universally optimal algorithms in various settings [17, 29, 16, 25]. We highlight here the paper by Haeupler, Wajc, and Zuzic [17] which gives a universally optimal algorithm in the supported CONGEST model for the minimum spanning tree; the techniques used in that paper are different from those that we use, despite both papers considering the MST problem.

Recently, it was shown that Dijkstra’s algorithm is universally optimal for a version of the single-source shortest paths problem [15] in the standard Word-RAM model. To the best of our knowledge, that paper was the first universal optimality result in a non-distributed setting. This makes this paper the second such result.

1.3 Future work

We believe that our technique can be applied to other graph problems. Specifically, the framework that we use for our lower bound seems to be quite general. We believe that it is likely that the same techniques could be used for releasing shortest-path trees. With some additional tweaks, we believe our techniques could be useful for problems such as maximum-weight matching or minimum-weight perfect matching. Extending our results to approximate differential privacy would also be of great interest.

2 Preliminaries

In this paper, we consider all graphs to be simple, undirected and connected. We consider the setting introduced by Sealfon [26], where the unweighted graph G=(V,E) is public and fixed, and the only private information are the edge weights 𝐰E. We also assume that G has at least two different spanning trees, i.e., it is not itself a tree. We denote by 𝒯(G) the set of all spanning trees of G, and identify each T𝒯(G) with the set of its edges. It is folklore that for all connected graphs, 1|𝒯(G)|nn2, with the maximum attained when G is a clique. We write 𝐰(T) as a shortcut for eT𝐰(e), and write T𝐰 to denote the minimum spanning tree under weights 𝐰. If 𝐰 is clear from context, we write just T. For a spanning tree T, its error is defined as 𝐰(T)𝐰(T).

2.1 Differential Privacy

We define two notions of adjacency for weight vectors: 1, defined so that 𝐰1𝐰 if and only if 𝐰𝐰11, and , defined so that 𝐰𝐰 if and only if 𝐰𝐰1.

A mechanism for MST is any randomized algorithm that, for a fixed and public unweighted graph G, takes as input a weight vector 𝐰 and outputs a spanning tree of G, specified by the list of its edges.333Formally, we have infinitely many mechanisms, each for one graph G. What we will do instead is to pretend that there is a single mechanism that accepts G as an additional parameter. We are interested in minimizing the expected error of 𝒜, defined as 𝔼T𝒜(G,𝐰)[𝐰(T)]𝐰(T). Furthermore, 𝒜 is ε-differentially private with respect to (which is either 1 or ), if, for every 𝐰𝐰 and every T𝒯(G),

Pr[𝒜(G,𝐰)=T]eεPr[𝒜(G,𝐰)=T],

where ε>0 is a parameter that controls the tradeoff between privacy and the expected error of 𝒜.

2.2 Spanning Trees

We define the following metric on the space of spanning trees: dH(T1,T2)|T1T2|.444The reader is invited to verify that dH is indeed a metric. We call dH the Hamming metric or Hamming distance between T1 and T2. Note that |T1T2|=|T2T1| and we could have used either in the previous definition. We then define diam𝒯(G)maxT1,T2𝒯(G)dH(T1,T2) as the diameter of the space of spanning trees of G with respect to dH. Trivially, diam𝒯(G)n1, but it can be much smaller: for example, we have diam𝒯(G)=1 when G is a cycle, and generally, diam𝒯(G)k if G has at most n1+k edges. In Section 5, we provide an exponential lower and upper bound on the relationship between diam𝒯(G) and |𝒯(G)|.

In the lower bounds, we will make use of special zero-one weight vectors, derived from spanning trees:

Definition 1.

For a spanning tree T𝒯(G), define the weights 𝟙TRE as 𝟙T(e)=0 if eT, and 𝟙T(e)=1 otherwise.

Fact 2.

For two trees T1,T2𝒯(G), it holds 𝟙T1(T2)=|T2T1|=dH(T1,T2)=|T1T2|=𝟙T2(T1). In particular, 𝟙T(T)=0. It also holds that 𝟙T1𝟙T21=2dH(T1,T2) and 𝟙T1𝟙T21 (with equality if T1T2).

2.3 Universal Optimality

Universal optimality is a notion that, intuitively speaking, says that an algorithm is optimal for any fixed graph topology. It is most commonly used with respect to the time complexity, but here, we instead define it in terms of an expected error of an ε-differentially private mechanism.

Definition 3.

Let 𝒫 be any optimization problem on weighted graphs where for every input (G,𝐰)𝒳,555Here 𝒳 is the set of all problem inputs; in our specific problem, this is the (uncountably infinite) set of all possible weighted connected graphs with all possible choices of edge weights. the goal is to produce an output y𝒴 minimizing some scoring function μ(G,𝐰,y). Define μ(G,𝐰)=miny𝒴μ(G,𝐰,y). For a fixed graph G and an algorithm 𝒜, define worst-case expected error of 𝒜 on G as

R(𝒜,G)max{𝔼[μ(G,𝐰,𝒜(G,𝐰))]μ(G,𝐰)|𝐰:(G,𝐰)𝒳}.

We say that an ε-differentially private mechanism 𝒜:𝒳𝒴 is universally optimal for 𝒫, if there exists a constant c>0 such that for any unweighted graph G and any other ε-differentially private mechanism 𝒜, we have R(𝒜,G)cR(𝒜,G). We instead say that 𝒜 is universally optimal up to factor f(G) if R(𝒜,G)cf(G)R(𝒜,G).

3 Simple Mechanism for Privately Releasing the MST

In this section, we show a tighter analysis of a very simple mechanism for privately releasing an MST, which originally appeared in Sealfon [26]. Whereas the original analysis proves that the expected error is at most 𝒪(nlogn/ε) for the 1 neighbor relation, we prove a tighter bound of 𝒪(Dlogn/ε) for D=diam𝒯(G) (note that Dn1). We prove in Section 4 a lower-bound of Ω(D/ε), showing that the algorithm is universally near-optimal. On the other hand, in Claim 26 we prove that for , the algorithm is neither worst-case nor universally optimal.

Our goal is to prove the following corollary. It follows from Corollary 7 (which states the upper bound), Theorem 9 (which states the lower bound) and the fact that the time complexity of Algorithm 5 is dominated by the runtime of an MST algorithm.

Corollary 4.

Algorithm 5 is ε-differentially private under the 1 neighbor relation 1 for any ε=𝒪(1). It is universally optimal up to an 𝒪(logn) factor for releasing the MST under the 1 neighbor relation. It runs in near-linear time.

Algorithm 5 (MST via postprocessing).

Given the weight vector 𝐰, let b=1/ε for 1 and b=m/ε for . Release the noisy weights 𝐰^ obtained by, for each edge, independently sampling 𝐰^(e)𝐰(e)+Lap(b), where Lap(b) is the Laplacian distribution with mean 0 and scale b. Calculate the MST of (G,𝐰^) and return it.

Theorem 6.

Algorithm 5, denoted here as 𝒜, is ε-differentially private for both 1 and . For 1, and for any γ>0, it holds that

PrT𝒜(G,𝐰)[𝐰(T)𝐰(T)+4Dlog(n/γ)ε]1γ,

where T is the MST of (G,𝐰) and D=diam𝒯(G).

The idea of our proof is analogous to the original proof by Sealfon [26], except that in the last step, instead of bounding the error incurred by all edges of T and T, we bound the (smaller) error incurred by the 2D edges in which T and T differ.

Proof.

By the guarantees of the Laplace mechanism [9], we can privately release the noised weight vector, where for , we additionally use that 𝐰𝐰1m for 𝐰𝐰. The privacy of Algorithm 5 then follows from the privacy of postprocessing.

Fix γ>0. For each edge e, it holds that Pr[|𝐰(e)𝐰^(e)|log(m/γ)/ε]=1γ/m by the definition of Lap(). By the union bound, the probability that |𝐰(e)𝐰^(e)|log(m/γ)/ε holds for all edges is at least 1γ. Let us condition on this event.

Let T be the spanning tree returned by Algorithm 5, i.e., the MST of (G,𝐰^), and let T be the MST of (G,𝐰). We can write

𝐰(T)𝐰(T) =eTT𝐰(e)eTT𝐰(e)
eTT𝐰^(e)eTT𝐰^(e)+2Dlog(m/γ)/ε
=𝐰^(T)𝐰^(T)+2Dlog(m/γ)/ε
2Dlog(m/γ)/ε.

We used, respectively, the fact that edges in TT do not contribute to the error, the fact that |TT|=|TT|D, rewriting, and the fact that T is an MST under 𝐰^. Noting that log(m/γ)log(n2/γ)=2log(n/γ) finishes the proof.

Corollary 7.

Let 𝒜 be Algorithm 5 in the setting with 1. It holds that 𝔼T𝒜(G,𝐰)[𝐰(T)]𝐰(T)4D(logn+1)/ε, where T is the MST of (G,𝐰) and D=diam𝒯(G).

Proof.

By Theorem 6, we have

PrT𝒜(G,𝐰)[𝐰(T)𝐰(T)4D(logn+log(1/γ))ε]1γ,

The claim then follows from the following lemma, with a=4D/ε and b=logn.

Lemma 8.

Let X be a random variable and let us have a>0, b, such that for every γ(0,1], we have Pr[Xa(log(1/γ)+b)]1γ. Then 𝔼[X]a(b+1).

Proof.

Equivalently, we can write Pr[X/ablogγ]1γ. Now let x be such that γ=exp(x). We have Pr[X/abx]1exp(x). Denote Y=Xab and let ZExp(1), where Exp(λ) is the exponential distribution. For any x, we have Pr[Yx]1exp(x)=Pr[Zx], i.e., Z stochastically dominates Y, and thus 𝔼[Y]𝔼[Z]=1. Thus, by linearity of expectation, 𝔼[X]=a(𝔼[Y]+b)a(b+1), as needed.

4 Lower Bounds for MST

In this section, we focus on proving the lower bound. For 1, this is a lower bound that nearly matches the performance of Algorithm 5, for it nearly matches the performance of the mechanism from Section 6.

In both cases, there is a logn gap between the lower and upper bounds. This gap is inherent to our approach, but for some graphs, and in particular, for G=Kn, we can make it disappear and get worst-case lower bounds of Ω(nlogn/ε) (for 1) and Ω(n2logn/ε) (for ) that match our worst-case upper bounds from Section 6 up to a constant factor, as well as that of Sealfon [26] in the case of 1. Overall, we prove the following theorem:

Theorem 9.

Fix an unweighted graph G and let 𝒜 be mechanism for MST on G. If 𝒜 is ε-differentially private with respect to 1, then there exist weights 𝐰 such that 𝔼T𝒜(G,𝐰)[𝐰(T)]=𝐰(T)+Ω(D/ε)𝒪(1), where D=diam𝒯(G). Moreover, there exists at least one G and 𝐰 where 𝔼T𝒜(G,𝐰)[𝐰(T)]=𝐰(T)+Ω(nlogn/ε)𝒪(1).

If 𝒜 is ε-differentially private with respect to instead, then, for every fixed G, there exist weights 𝐰 such that 𝔼T𝒜(G,𝐰)[𝐰(T)]=𝐰(T)+Ω(D2/ε)𝒪(D). Moreover, there exists at least one G and 𝐰 where 𝔼T𝒜(G,𝐰)[𝐰(T)]=𝐰(T)+Ω(n2logn/ε)𝒪(n).

The rough outline of the proof is as follows: in Lemmas 10 and 11, we state (and restate in a language of MSTs) a general packing-based lower bound that applies whenever we can find many inputs (in our case, weight vectors) close in the metric induced by the neighbor relation such that, for each input, the set of all outputs (in our case, spanning trees) that give small error with respect to this input, is disjoint with all the other sets. In Lemma 12, we prove that instead of searching for a good set of weight vectors, we can search for a large set of spanning trees in which every two spanning trees differ in many edges. Lemmas 13 and 14 prove that such a large set always exists, with the latter being a special case providing stronger guarantees when the graph is a clique. We postpone their proofs to Section 5, where we also build the needed theory.

At the core of our lower bound is the following lemma, based on a general packing argument.

Lemma 10 (Vadhan [27], Theorem 5.13).

Let 𝒞𝒳 be a collection of datasets all at (neighbor-relation-induced) distance at most r from some fixed dataset x0𝒳, and let {x}x𝒞 be a collection of disjoint subsets of 𝒴. If there is an ε-differentially private mechanism :𝒳𝒴 such that Pr[(x)x]p for every x𝒞, then perε/|𝒞|.

The following rephrases Lemma 10 in the language of our problem. It also picks a specific way of constructing the sets 𝐰, namely, by including precisely those outputs that have a “small enough” error with respect to 𝐰.

Lemma 11 (Adaptation of Lemma 10 for MST).

Fix an unweighted graph G=(V,E) and let be an arbitrary neighbor relation on E. Given 𝒲E a collection of weight vectors, all at (-induced) distance at most r from some fixed weight vector 𝐰0E, and a parameter x0, denote for each 𝐰𝒲 the MST of (G,𝐰) by T𝐰, and define 𝐰{T𝒯(G)𝐰(T)𝐰(T𝐰)+x} the set of spanning trees that are “light” under 𝐰. Assume that 𝒲 and x are such that all 𝐰 are pairwise disjoint. Then for any ε-differentially private (with respect to ) mechanism :E𝒯(G), there exist weights 𝐰𝒲, such that PrT(𝐰)[𝐰(T)𝐰(T𝐰)+x]erε/|𝒲|.

It turns out that there is a very natural class of sets 𝒲 that give a reasonably good lower bound. Namely, the 𝒲 we use in our lower bound will be of the form 𝒲{0,α}E for some choice of α. This is formalized in the following statement. It says that to create our 𝒲, we can start with any S𝒯(G), and then use the mapping Tα𝟙T (recall that 𝟙T is the indicator function of a set ET, see Definition 1). The quality of the lower bound provided by S depends solely on two things: the size of S, and the minimum Hamming distance between distinct T1,T2S. The parameter α>0 can then be used to control the tradeoff between x and the probability that the error will be smaller than x in Lemma 11.

Lemma 12.

Fix an unweighted graph G and denote D=diam𝒯(G). Given a set of spanning trees S𝒯(G), let d>0 be such that dH(T1,T2)>d for all T1,T2S. Finally, let 𝒜 be a mechanism for releasing a minimum spanning tree of G. If 𝒜 is ε-differentially private with respect to 1, then there exist weights 𝐰 such that

PrT𝒜(G,𝐰)[𝐰(T)𝐰(T)+dD(log|S|8ε14)]1|S|.

If 𝒜 is ε-differentially private with respect to , then there exist weights 𝐰 such that

PrT𝒜(G,𝐰)[𝐰(T)𝐰(T)+d(log|S|4ε12)]1|S|.
Proof.

Let us walk through the proof with the assumption that 𝒜 is ε-differentially private with respect to 1. At the very end, we will discuss the needed changes for .

Fix a parameter α and define 𝒲 as {α𝟙TTS}. Later we will specify the value of α that gives the needed bound.

Fix 𝐰0=α𝟙T0𝒲 arbitrarily. In order to apply Lemma 11, we need to determine r and x. For each 𝐰=α𝟙T𝒲, we have 𝐰𝐰01=2αdH(T,T0)2αD, and thus r=2αD.

Set x=αd/2. Then for every 𝐰=α𝟙T𝒲, we have:

𝐰 ={T𝒯(G)𝐰(T)<𝐰(T)+x}={T𝒯(G)α𝟙T(T)<αd/2}
={T𝒯(G)|TT|<d/2}={T𝒯(G)dH(T,T)<d/2}.

We can conclude that all 𝐰 are disjoint: If we had T𝐰1𝐰2 for distinct 𝐰1=α𝟙T1𝒲 and 𝐰2=α𝟙T2𝒲, then we would have dH(T1,T2)dH(T1,T)+dH(T,T2)<d, which would contradict the properties of d, as T1,T2S.

Now we apply Lemma 11 to get that, for every ε-DP mechanism for releasing the MST of G there exist weights 𝐰𝒲E, such that

PrT𝒜(G,𝐰)[𝐰(T)𝐰(T)+αd2] exp(mε)|S|=exp(2αDε)|S|exp((2αD+1)ε)|S|.

Setting α=1/4log|S|/(εD)1/2D yields:

PrT𝒜(G,𝐰)[𝐰(T)𝐰(T)+dD(log|S|8ε14)]1|S|.

Finally, let us deal with the case when 𝒜 is ε-differentially private with respect to instead. The idea of the proof is identical and we only point out the differences. When calculating r, we now get that 𝐰𝐰0α, and thus r=α. By Lemma 11, and as αα+1, there exist weights 𝐰 such that

PrT𝒜(G,𝐰)[𝐰(T)𝐰(T)+αd2] exp((α+1)ε)|S|.

Setting α=1/2log|S|/ε1 yields:

PrT𝒜(G,𝐰)[𝐰(T)𝐰(T)+d(log|S|4ε12)]1|S|.

Lemma 12 reduces our problem into a problem of finding a set S𝒯(G), which is as large as possible, and at the same time, the Hamming distance between any two spanning trees in the set is large. In Section 5, we prove the following two results:

Lemma 13.

For any unweighted graph G with diam𝒯(G)=D, there exists a set S𝒯(G) of size 2Θ(D) such that for any distinct T1,T2S, we have dH(T1,T2)=Θ(D).

Lemma 14.

For any unweighted clique G on n>2 vertices, there exists a set S𝒯(G) of size 2Θ(nlogn) such that for any distinct T1,T2S, we have dH(T1,T2)=Θ(n).

Now we are ready to prove Theorem 9.

Proof of Theorem 9.

Lemma 12 says that for any mechanism 𝒜, there exist weights 𝐰 such that, if 𝒜 is ε-differentially private with respect to 1, then:

PrT𝒜(G,𝐰)[𝐰(T)𝐰(T)+dD(log|S|8ε14)x]|S|1/2

for D=diam𝒯(G) and d such that dH(T1,T2)<d for any distinct T1,T2S. This means that Pr[𝐰(T)>𝐰(T)+x]1|S|1/2=Ω(1), and thus, as d/D1:

𝔼[𝐰(T)]𝐰(T)+Ω(x)=𝐰(T)+Ω(dlog|S|Dε)𝒪(1).

Now, if S is from Lemma 13, we have log|S|=Θ(D) and d=Θ(D). If G=Kn then instead we take S from Lemma 14, and log|S|=Θ(nlogn) and d=Θ(D). Substituting twice in the equation above proves the first half of the theorem.

If, instead, 𝒜 is ε-differentially private with respect to , there likewise exist weights 𝐰 such that:

PrT𝒜(G,𝐰)[𝐰(T)𝐰(T)+d(log|S|4ε12)]|S|1/2,

and by a similar argument, 𝔼[𝐰(T)]𝐰(T)+Ω(dlog|S|/ε)𝒪(d). Now, we can again substitute for log|S| and d according to either Lemma 13 (if G is a general graph), or Lemma 14 (if G is a clique). This proves the second half of the theorem.

5 Finding a Large Set of Dissimilar Trees

In this section, our goal is to prove Lemmas 13 and 14, which assert the existence of a large set S of spanning trees such that every two spanning trees differ in many edges. In Section 5.1, we state some common properties of spanning trees and prove that there are at least 2D spanning trees (for D=diam𝒯(G)). In Section 5.2, we show how to embed binary block codes into the 2D spanning trees from Section 5.1, which leads to our first method of constructing S, and proving Lemma 13; this is the lemma that we need in order to prove our universal optimality results.

In Section 5.3, we bound the number of trees in the d-ball around some tree T, and use this in conjunction with a greedy packing argument to provide a different method of constructing S that gives slightly different guarantees than the one in Section 5.2. We use this to prove Lemma 14; this is the lemma that we need to prove our worst-case optimality results.

5.1 Properties of Spanning Trees

Here we state some simple properties of spanning trees. Although (some of) these results could be considered folklore, we give proofs for completeness.

Lemma 15 (Exchange lemma).

Let Tx,Ty𝒯(G) be two spanning trees and let eTyTx. Then there exists fTxTy such that T=Tx{e}{f} is also a spanning tree. Furthermore, |TyT|=|TyTx|1.

Proof.

The graph Tx{e} has exactly one cycle C. Ty does not have cycles, and C must thus contain an edge fTy; furthermore, fe, as eTy. But then fC{e}Tx and thus fTxTy as needed, and T=Tx{e}{f} is again a tree. Finally, |TyT|=|TyTx|1, as removing f had no effect on |TyT| and adding e decreased it by 1.

Lemma 16 (Iterated exchange lemma).

Given two spanning trees Ta,Tb𝒯(G), and a set of edges QTbTa, there exists a spanning tree TQ such that TQTa=Q and |TbTQ|=|TbTa||Q|.

Proof.

Let k=|TbTa|. The claim follows by induction on |Q|. If |Q|=0, then we can set TQTa. Otherwise, take any eQ, and let Q=Q{e}. By induction, let T be the tree such that TTa=Q and |TbT|=|TbTa||Q|=k|Q|+1. Now invoke Lemma 15 with Tx=T, Ty=Tb and e to obtain fTTb and a tree T=T{e}{f} satisfying |TbT|=|TbT|1=k|Q|.

We claim that TTaQ, since TTa=QQ by induction, and the only edge T additionally contains is eQ. But simultaneously, by triangle inequality, dH(Ta,T)dH(Ta,Tb)dH(T,Tb)=k(k|Q|)=|Q|. Hence, TTaQ and |TTa|=|Q|, and thus TTa=Q as needed and we can set TQT.

Corollary 17.

For every graph G, it holds that |𝒯(G)|2D for D=diam𝒯(G).

Proof.

Fix any two Ta,Tb𝒯(G) such that |TbTa|=D. By Lemma 16, we have that for any QTbTa, there exists a spanning tree TQ such that TQTa=Q. As there are 2D possible choices of Q, and each of them yields a unique spanning tree, we can conclude that there are at least 2D different spanning trees.

5.2 Dissimilar Trees via Binary Codes

In this section, we show that the set 𝒵 of 2D trees from Corollary 17, behaves, in some sense, as the space {0,1}D. Namely, there is a correspondence between 𝒵 and {0,1}D, such that if 𝐱,𝐲{0,1}D differ in k positions, then their corresponding spanning trees have Hamming distance at least k/2. In this way, we reduce the problem of finding a set S𝒵 of dissimilar spanning trees to the problem of finding a good binary block code.

Lemma 18.

Given two spanning trees Ta, Tb, let Q1,Q2TbTa. Let TQ1 and TQ2 be trees such that TQ1Tb=Q1 and TQ2Tb=Q2. Then it holds that Q1Q2TQ1TQ2.

We note that TQ1 and TQ2 always exist thanks to Lemma 16.

Proof.

By rules for set subtraction, we have Q1Q2=(TQ1Tb)(TQ2Tb)=(TQ1TQ2)TbTQ1TQ2.

We briefly recall the definition of a block code. Note that we use the less common definition of an (n,M,d)2 code where M is not the message length, but the (exponentially larger) number of codewords.

Definition 19.

An (n,M,d)2 code is a set 𝒞{0,1}n such that |𝒞|M and every two different vectors 𝐱,𝐲𝒞 differ in at least d positions.

Next, we prove the reduction between finding a set of dissimilar spanning trees and finding a good block code:

Lemma 20.

Let 𝒞 be a (D,M,d+1)2 code and let G be an unweighted graph such that D=diam𝒯(G). Then there exists a set S𝒯(G) such that |S|=M and dH(T1,T2)>d/2 for any two different T1,T2S.

Proof.

We will construct S as follows: first, we fix Ta and Tb such that dH(Ta,Tb)=D, as in Corollary 17. We number the edges of TbTa in any order as e1,,eD. Now, for every 𝐱𝒞, define Q𝐱{eii{1,,D}𝐱i=1}, and let TQ𝐱 be the tree obtained by invoking Lemma 16. Namely, TQ𝐱 satisfies TQ𝐱Ta=Q𝐱. Finally, we set S={TQ𝐱𝐱𝒞}.

Clearly |S|=|𝒞|=M, and we need to show that dH(TQ𝐱,TQ𝐲)>d/2 for all distinct 𝐱,𝐲𝒞. Note that the number of positions in which 𝐱 and 𝐲 differ is exactly |Q𝐱Q𝐲|+|Q𝐲Q𝐱|. Now we can use Lemma 18, to write

d+1|Q𝐱Q𝐲|+|Q𝐲Q𝐱||TQ𝐱TQ𝐲|+|TQ𝐲TQ𝐱|=2dH(TQ𝐱,TQ𝐲),

and thus dH(TQ𝐱,TQ𝐲)>d/2, as needed.

Finally, we show that there always exists a good block code:

Lemma 21.

For every n, there exists an (n,2n/3,n/6+1)2 code.

Proof.

First assume that n is divisible by 6. By the Gilbert–Varshamov bound [14, 28], there exists a (n,K,n/6+1)2 code for some K that satisfies 2n/Ki=0n/6(ni).

Using the bound on the sum of binomial coefficients (see e.g. Flum and Grohe, p. 427 [12]), we obtain i=0n/62nH(1/6) with H(p) being the binary entropy function H(p)=plogp(1p)log(1p). One can verify that H(1/6)2/3 and thus K2n/2n2/3=2n/3 as needed.

Finally, if n is not divisible by 6, we can apply the lemma with n=6n/6 and then pad every codeword of the resulting code with nn zeros.

Combination of these results proves Lemma 13:

Proof of Lemma 13.

Combining Lemmas 20 and 21 and setting n=D in the latter immediately yields S𝒯(G) with |S|=2Θ(D) and d=Θ(D).

5.3 Dissimilar Trees via Greedy Packing

In this section, we provide a different approach for finding a large set S of dissimilar spanning trees. It works by producing a crude upper bound U on the number of trees in the d-ball around a tree T, and then using a greedy packing argument to show that we can always find S of size |S||𝒯(G)|/U.

Lemma 22 (Volume of a d-ball around a spanning tree).

For a graph G, T𝒯(G), and d>0, it holds that |{T𝒯(G)dH(T,T)d}|mdnd.

Proof.

Any T with dH(T,T)=dd can be fully (and possibly non-uniquely) described by a list L+ of d edges eET to be added to T and another list L of d edges eT to be removed. Furthermore, both lists can be padded to have length exactly d by repeating arbitrary entries. As there are at most (mn+1)d(n1)dmdnd possible pairs (L+,L)(ET)d×Td of lists of length d, there must be at most mdndmdnd possible trees T.

Lemma 23 (Greedy packing).

For a graph G, and a parameter d>0, there exists a set S𝒯(G) such that dH(T1,T2)>d for all distinct T1,T2S and furthermore, |S||𝒯(G)|/mdnd.

Proof.

We will construct S greedily: start with X=𝒯(G). As long as X is nonempty, pick arbitrary TX and add it to S. Then, set XX{TdH(T,T)<d}, and repeat. By Lemma 22, in each step we remove at most mdnd elements from a set of size |𝒯(G)|, and therefore only stop after S contains at least |𝒯(G)|/(mdnd) elements.

Now we are ready to prove Lemma 14:

Proof of Lemma 14.

We invoke Lemma 23 on G with d=(n2)/6. Since G is a clique, we have |𝒯(G)|=nn2. Clearly, d=Θ(n) and |S||𝒯(G)|=2𝒪(nlogn), and we can write

|S||𝒯(G)|mdnd|𝒯(G)|n3d=|𝒯(G)|n(n2)/2=|𝒯(G)||𝒯(G)|=|𝒯(G)|=2Ω(nlogn).

Lemma 22 also gives us the following relationship between |𝒯(G)| and D:

Lemma 24.

For a graph G with diam𝒯(G)=D, it holds that |𝒯(G)|23Dlog2n.

Proof.

Take any T𝒯(G) and define S={T𝒯(G)dH(T,T)D}. Necessarily S=𝒯(G) by the definition of D. Now we invoke Lemma 22 to conclude that |𝒯(G)|=|S|mDnDn3D=23Dlog2n.

6 Universal Near-Optimality via the Exponential Mechanism

In this section, we start by showing that Algorithm 5 is in fact not universally optimal for . The main contribution of this section is then that we prove that the exponential mechanism is universally near-optimal with respect to both 1 and . We also show that it can be implemented in polynomial time by relying on a result of Colbourn, Myrvold, and Neufeld [6]. The properties of the exponential mechanism that we rely on are summarized in Fact 31 in Appendix A.

Our goal is to prove the following corollary. It follows from Theorem 29 (which states the upper bounds and time complexity) and Theorem 9 (which states the lower bounds).

Corollary 25.

For any ε=𝒪(1), the exponential mechanism with loss function μ(𝐰,T)=𝐰(T) is universally optimal up to an 𝒪(logn) factor for releasing the MST, in both the 1 and the neighbor relations. It can be implemented in the matrix multiplication time 𝒪(nω).

We now show that Algorithm 5 is neither worst-case, nor universally optimal. Note also that when we are using the neighbor relation, the noise magnitude used by the algorithm is indeed optimal in the sense that any lower noise magnitude will not lead to the weights themselves being private after adding the noise. This can be easily seen as follows: With the current amount of noise added, if each weight changes by 1, we lose up to ε/m privacy on each edge. Since the composition theorem for pure differential privacy is tight, we thus may indeed lose up to ε privacy in total. Any lower amount of noise would not give ε-differential privacy.

Claim 26.

Denote Algorithm 5 used with the neighbor relation as 𝒜. For every graph G, there exist weights 𝐰 such that 𝔼T𝒜(G,𝐰)[𝐰(T)]=𝐰(T)+Ω(mD/ε)𝒪(1).

Proof.

The claim follows immediately from the fact that 𝒜 is also ε/m-differentially private with respect to 1, and thus by the first part of Theorem 9 with ε=ε/m, such weights 𝐰 must exist.

Below, we will prove that one can in fact achieve an expected error of 𝒪(D2logn/ε). This implies that Algorithm 5 is in fact neither universally, nor worst-case optimal for .

In the rest of this section, our goal is to prove that the exponential mechanism can be implemented in polynomial time and that it is universally optimal for releasing the MST. We start by stating a useful result on efficiently sampling spanning trees.

Lemma 27.

There is an algorithm that, given an unweighted graph G, a weight vector 𝐰, and a parameter λ, samples a spanning tree of G such that the probability that T𝒯(G) is returned is proportional to exp(λ𝐰(T)). It runs in matrix multiplication time 𝒪(nω).

Proof.

Such an algorithm is provided in Colbourn, Myrvold, and Neufeld [6]. The original paper only deals with unweighted graphs, but it is mentioned in Durfee et al. [8] that this approach is actually easily generalized to the weighted case.

Note that generally, any exact spanning tree sampling algorithm that supports weighted graphs works for Lemma 27. There are faster algorithms available, but every faster algorithm known to us either does not sample from the exact distribution (failing or sampling from a different distribution with some small probability δ), or does not support weighted graphs out of the box.

The following lemma allows us to analyze the exponential mechanism more tightly by changing the loss function so that the outcome probabilities do not change, but the global sensitivity decreases.

Lemma 28.

Let μ,μ:𝒳×𝒴 be two loss functions related in the following way: for each x𝒳, there exists cx such that for all y𝒴, μ(x,y)=μ(x,y)+cx.

Given λ, let 𝒜 and 𝒜 be instantiations of the exponential mechanism that, given x𝒳, sample y𝒴 with probability proportional to exp(λμ(x,y)) and exp(λμ(x,y)), respectively. Then 𝒜 and 𝒜 are equivalent, that is, for each x, they return the same distribution on 𝒴.

Proof.

𝒜(x) returns y with probability

exp(λμ(x,y))y𝒴exp(λμ(x,y))=exp(λcx)exp(λμ(x,y))y𝒴exp(λcx)exp(λμ(x,y))=exp(λμ(x,y))y𝒴exp(λμ(x,y)),

which is exactly the probability of 𝒜(x) returning y.

Theorem 29.

There is an 𝒪(nω)-time mechanism 𝒜 for MST, ε-differentially private with respect to 1, such that, for every weighted graph (G,𝐰),

𝔼T𝒜(G,𝐰)[𝐰(T)]𝐰(T)+2log|𝒯(G)|ε=𝐰(T)+𝒪(Dlognε),

where T is the MST of (G,𝐰) and D=diam𝒯(G). Furthermore, there is an 𝒪(nω)-time mechanism 𝒜 for MST, ε-differentially private with respect to , such that, for every weighted graph (G,𝐰),

𝔼T𝒜(G,𝐰)[𝐰(T)]𝐰(T)+4Dlog|𝒯(G)|ε=𝐰(T)+𝒪(D2lognε).
Proof.

The asymptotic bounds on the error follow from the exact ones by Lemma 24, thus we will only focus on the exact inequalities. Let us assume the case first; we will deal with the 1 case at the end of the proof.

𝒜 will be an instantiation of the exponential mechanism from Lemma 27, with μ(𝐰,T)𝐰(T), and with λ determined later.

We will use Lemma 28 to analyze an equivalent exponential mechanism 𝒜 that uses the loss function μ defined as follows: fix globally some T0𝒯(G) and define μ(𝐰,T)𝐰(T)𝐰(T0). It holds that, for every fixed 𝐰, we can write μ(𝐰,T)=μ(𝐰,T)+c𝐰, where c𝐰=𝐰(T0) does not depend on T, and thus 𝒜 and 𝒜 are equivalent by Lemma 28.

Let us choose the right λ for 𝒜 (and thus also for 𝒜). By the standard properties of the exponential mechanism (see Fact 31), 𝒜 is ε-differentially private if we choose λε/(2Δ), where Δ is the global sensitivity of μ, as defined in Fact 31. As a next step, we bound Δ. For each 𝐰𝐰, we have:

|μ(𝐰,T)μ(𝐰,T)| =|(𝐰𝐰)(T)(𝐰𝐰)(T0)|
=|eTT0(𝐰𝐰)(e)eT0T(𝐰𝐰)(e)|
eTT0|(𝐰𝐰)(e)|+eT0T|(𝐰𝐰)(e)|
2dH(T0,T)2R0,

for R0maxT𝒯(G)dH(T0,T). We used the fact that edges present in both T and T0 do not count towards the result. Hence, Δ2R02D. If we thus choose λ=ε4R0 in 𝒜, we immediately get from Fact 31 that 𝒜 is ε-differentialy private and the expected error is at most 4R0log|𝒯(G)|/ε4Dlog|𝒯(G)|/ε, as needed. By the equivalence of 𝒜 and 𝒜, the same holds for 𝒜.

Finally, note that 𝒜 can compute R0 (and thus λ) quickly: namely, if we denote by T the MST of a graph (G,𝟙T0), then R0=dH(T0,T). That is because T minimizes the expression 𝟙T0(T), which, by Fact 2, is equal to dH(T0,T), just as needed. The MST can be computed in linear time using e.g. the Jarník-Prim algorithm with a double-ended queue as the priority queue, as all weights are either 1 or 0.

Let us now deal with the 1 case. 𝒜 will again be an instantiation of the exponential mechanism. This time, we set λ=ε/2 and analyze 𝒜 directly, without the use of Lemma 28. For any 𝐰1𝐰 and T𝒯(G), we immediately have |𝐰(T)𝐰(T)|𝐰𝐰11, and thus the global sensitivity of μ is Δ1. By Fact 31, 𝒜 is ε-differentially private and the expected error is at most 2log|𝒯(G)|/ε, exactly as needed.

Since R0 computed in the above proof satisfies D/2R0D, we immediately get the following corollary:

Corollary 30.

A 2-approximation of D=diam𝒯(G) can be computed in linear time.

Note that the above algorithm is actually strictly stronger than Algorithm 5, as there are graphs where log|𝒯(G)|=o(Dlogn). We suspect that, in fact, the exponential mechanism is universally optimal for both 1 and , but we were not able to prove a stronger lower bound.

References

  • [1] Hilal Asi and John C. Duchi. Instance-optimality in differential privacy via approximate inverse sensitivity mechanisms. In Advances in Neural Information Processing Systems 33: Annual Conference on Neural Information Processing Systems 2020, NeurIPS 2020, December 6-12, 2020, virtual, volume 33, pages 14106–14117, 2020. URL: https://proceedings.neurips.cc/paper/2020/hash/a267f936e54d7c10a2bb70dbe6ad7a89-Abstract.html.
  • [2] Raef Bassily, Kobbi Nissim, Adam D. Smith, Thomas Steinke, Uri Stemmer, and Jonathan R. Ullman. Algorithmic stability for adaptive data analysis. In Proceedings of the 48th Annual ACM SIGACT Symposium on Theory of Computing, STOC 2016, Cambridge, MA, USA, June 18-21, 2016, pages 1046–1059. ACM, 2016. doi:10.1145/2897518.2897566.
  • [3] Jaroslaw Błasiok, Mark Bun, Aleksandar Nikolov, and Thomas Steinke. Towards instance-optimal private query release. In Proceedings of the Thirtieth Annual ACM-SIAM Symposium on Discrete Algorithms, SODA 2019, San Diego, California, USA, January 6-9, 2019, pages 2480–2497. SIAM, SIAM, 2019. doi:10.1137/1.9781611975482.152.
  • [4] Solenn Brunet, Sébastien Canard, Sébastien Gambs, and Baptiste Olivier. Edge-calibrated noise for differentially private mechanisms on graphs. In 14th Annual Conference on Privacy, Security and Trust, PST 2016, Auckland, New Zealand, December 12-14, 2016, pages 42–49. IEEE, IEEE, 2016. doi:10.1109/PST.2016.7906935.
  • [5] Justin Y. Chen, Shyam Narayanan, and Yinzhan Xu. All-pairs shortest path distances with differential privacy: Improved algorithms for bounded and unbounded weights. CoRR, abs/2204.02335, 2022. doi:10.48550/arXiv.2204.02335.
  • [6] Charles J. Colbourn, Wendy J. Myrvold, and Eugene Neufeld. Two algorithms for unranking arborescences. Journal of Algorithms, 20(2):268–281, 1996. doi:10.1006/jagm.1996.0014.
  • [7] Wei Dong and Ke Yi. A nearly instance-optimal differentially private mechanism for conjunctive queries. In PODS ’22: International Conference on Management of Data, Philadelphia, PA, USA, June 12 – 17, 2022, pages 213–225. ACM, 2022. doi:10.1145/3517804.3524143.
  • [8] David Durfee, Rasmus Kyng, John Peebles, Anup B. Rao, and Sushant Sachdeva. Sampling random spanning trees faster than matrix multiplication. In Proceedings of the 49th Annual ACM SIGACT Symposium on Theory of Computing, STOC 2017, Montreal, QC, Canada, June 19-23, 2017, pages 730–742. ACM, 2017. doi:10.1145/3055399.3055499.
  • [9] Cynthia Dwork, Frank McSherry, Kobbi Nissim, and Adam D. Smith. Calibrating noise to sensitivity in private data analysis. In Theory of Cryptography, Third Theory of Cryptography Conference, TCC 2006, New York, NY, USA, March 4-7, 2006, Proceedings, volume 3876 of Lecture Notes in Computer Science, pages 265–284. Springer, Springer, 2006. doi:10.1007/11681878_14.
  • [10] Chenglin Fan, Ping Li, and Xiaoyun Li. Private graph all-pairwise-shortest-path distance release with improved error rate. In Advances in Neural Information Processing Systems 35: Annual Conference on Neural Information Processing Systems 2022, NeurIPS 2022, New Orleans, LA, USA, November 28 – December 9, 2022, volume 35, pages 17844–17856, 2022. URL: http://papers.nips.cc/paper_files/paper/2022/hash/71b17f00017da0d73823ccf7fbce2d4f-Abstract-Conference.html.
  • [11] Natasha Fernandes, Annabelle McIver, Catuscia Palamidessi, and Ming Ding. Universal optimality and robust utility bounds for metric differential privacy. In 35th IEEE Computer Security Foundations Symposium, CSF 2022, Haifa, Israel, August 7-10, 2022, pages 348–363. IEEE, August 2022. doi:10.1109/CSF54842.2022.9919647.
  • [12] Jörg Flum and Martin Grohe. Parameterized Complexity Theory. Texts in Theoretical Computer Science. An EATCS Series. Springer, 2006. doi:10.1007/3-540-29953-X.
  • [13] Arpita Ghosh, Tim Roughgarden, and Mukund Sundararajan. Universally utility-maximizing privacy mechanisms. In Proceedings of the 41st Annual ACM Symposium on Theory of Computing, STOC 2009, Bethesda, MD, USA, May 31 – June 2, 2009, pages 351–360. ACM, 2009. doi:10.1145/1536414.1536464.
  • [14] Edgar N Gilbert. A comparison of signalling alphabets. The Bell system technical journal, 31(3):504–522, 1952.
  • [15] Bernhard Haeupler, Richard Hladík, Václav Rozhon, Robert E. Tarjan, and Jakub Tetek. Universal optimality of dijkstra via beyond-worst-case heaps. In 65th IEEE Annual Symposium on Foundations of Computer Science, FOCS 2024, Chicago, IL, USA, October 27-30, 2024, pages 2099–2130. IEEE, 2024. doi:10.1109/FOCS61266.2024.00125.
  • [16] Bernhard Haeupler, Harald Räcke, and Mohsen Ghaffari. Hop-constrained expander decompositions, oblivious routing, and distributed universal optimality. In STOC ’22: 54th Annual ACM SIGACT Symposium on Theory of Computing, Rome, Italy, June 20 – 24, 2022, pages 1325–1338. ACM, 2022. doi:10.1145/3519935.3520026.
  • [17] Bernhard Haeupler, David Wajc, and Goran Zuzic. Universally-optimal distributed algorithms for known topologies. In STOC ’21: 53rd Annual ACM SIGACT Symposium on Theory of Computing, Virtual Event, Italy, June 21-25, 2021, pages 1166–1179. ACM, 2021. doi:10.1145/3406325.3451081.
  • [18] Michael Hay, Chao Li, Gerome Miklau, and David D. Jensen. Accurate estimation of the degree distribution of private networks. In ICDM 2009, The Ninth IEEE International Conference on Data Mining, Miami, Florida, USA, 6-9 December 2009, pages 169–178. IEEE, IEEE Computer Society, 2009. doi:10.1109/ICDM.2009.11.
  • [19] Ziyue Huang, Yuting Liang, and Ke Yi. Instance-optimal mean estimation under differential privacy. In Advances in Neural Information Processing Systems 34: Annual Conference on Neural Information Processing Systems 2021, NeurIPS 2021, December 6-14, 2021, virtual, volume 34, pages 25993–26004, 2021. URL: https://proceedings.neurips.cc/paper/2021/hash/da54dd5a0398011cdfa50d559c2c0ef8-Abstract.html.
  • [20] Frank McSherry and Kunal Talwar. Mechanism design via differential privacy. In 48th Annual IEEE Symposium on Foundations of Computer Science (FOCS 2007), October 20-23, 2007, Providence, RI, USA, Proceedings, pages 94–103. IEEE, IEEE Computer Society, 2007. doi:10.1109/FOCS.2007.41.
  • [21] Kobbi Nissim, Sofya Raskhodnikova, and Adam D. Smith. Smooth sensitivity and sampling in private data analysis. In Proceedings of the 39th Annual ACM Symposium on Theory of Computing, San Diego, California, USA, June 11-13, 2007, pages 75–84. ACM, 2007. doi:10.1145/1250790.1250803.
  • [22] Rasmus Pagh and Lukas Retschmeier. Faster private minimum spanning trees. CoRR, abs/2408.06997, 2024. doi:10.48550/arXiv.2408.06997.
  • [23] Rafael Pinot. Minimum spanning tree release under differential privacy constraints. CoRR, abs/1801.06423, 2018. doi:10.48550/arXiv.1801.06423.
  • [24] Rafael Pinot, Anne Morvan, Florian Yger, Cédric Gouy-Pailler, and Jamal Atif. Graph-based clustering under differential privacy. In Proceedings of the Thirty-Fourth Conference on Uncertainty in Artificial Intelligence, UAI 2018, Monterey, California, USA, August 6-10, 2018, pages 329–338. AUAI Press, 2018. URL: http://auai.org/uai2018/proceedings/papers/132.pdf.
  • [25] Václav Rozhon, Christoph Grunau, Bernhard Haeupler, Goran Zuzic, and Jason Li. Undirected (1+ϵ)-shortest paths via minor-aggregates: near-optimal deterministic parallel and distributed algorithms. In STOC ’22: 54th Annual ACM SIGACT Symposium on Theory of Computing, Rome, Italy, June 20 – 24, 2022, pages 478–487. ACM, 2022. doi:10.1145/3519935.3520074.
  • [26] Adam Sealfon. Shortest paths and distances with differential privacy. In Proceedings of the 35th ACM SIGMOD-SIGACT-SIGAI Symposium on Principles of Database Systems, PODS 2016, San Francisco, CA, USA, June 26 – July 01, 2016, pages 29–41. ACM, 2016. doi:10.1145/2902251.2902291.
  • [27] Salil Vadhan. The complexity of differential privacy. Tutorials on the Foundations of Cryptography: Dedicated to Oded Goldreich, pages 347–450, 2017. doi:10.1007/978-3-319-57048-8_7.
  • [28] Rom Rubenovich Varshamov. Estimate of the number of signals in error correcting codes. Doklady Akad. Nauk, SSSR, 117:739–741, 1957.
  • [29] Goran Zuzic, Gramoz Goranci, Mingquan Ye, Bernhard Haeupler, and Xiaorui Sun. Universally-optimal distributed shortest paths and transshipment via graph-based 1-oblivious routing. In Proceedings of the 2022 ACM-SIAM Symposium on Discrete Algorithms, SODA 2022, Virtual Conference / Alexandria, VA, USA, January 9 – 12, 2022, pages 2549–2579. SIAM, SIAM, 2022. doi:10.1137/1.9781611977073.100.

Appendix A Exponential Mechanism

For completeness, we restate the guarantees of the exponential mechanism.

Fact 31 (Guarantees of the exponential mechanism [20, 2]).

Let μ:𝒳×𝒴 be a function, and let be a neighbor relation on 𝒳. The exponential mechanism 𝒜:𝒳𝒴 that, given x𝒳, samples y𝒴 with probability proportional to exp(ε2Δμ(x,y)), is ε-differentially private and satisfies:

𝔼y𝒜(x)[μ(x,y)]μ(x,y)+2Δlog|𝒴|ε,

where y is the minimizer of μ(x,) and Δ is the global sensitivity of μ, defined as

Δ=supxx𝒳maxy𝒴|μ(x,y)μ(x,y)|.