SlowGuess/NeurIPS_2023_OCR huggingface dataset:
Department of Computer Science and UVA Biocomplexity Institute and Initiative University of Virginia, USA dungn@virginia.edu
Mahantesh Halappanavar
Data Sciences and Machine Intelligence Group  
Pacific Northwest National Laboratory, USA  
hala@pnnl.gov
Venkatesh Srinivasan
Department of Mathematics and Computer Science Santa Clara University, USA vsrinivasan4@scu.edu
Anil Vullikanti
Department of Computer Science and UVA Biocomplexity Institute and Initiative University of Virginia, USA vsakumar@virginia.edu
One of the most common problems studied in the context of differential privacy for graph data is counting the number of non-induced embeddings of a subgraph in a given graph. These counts have very high global sensitivity. Therefore, adding noise based on powerful alternative techniques, such as smooth sensitivity and higher-order local sensitivity have been shown to give significantly better accuracy. However, all these alternatives to global sensitivity become computationally very expensive, and to date efficient polynomial time algorithms are known only for few selected subgraphs, such as triangles,  $k$ -triangles, and  $k$ -stars. In this paper, we show that good approximations to these sensitivity metrics can be still used to get private algorithms. Using this approach, we much faster algorithms for privately counting the number of triangles in real-world social networks, which can be easily parallelized. We also give a private polynomial time algorithm for counting any constant size subgraph using less noise than the global sensitivity; we show this can be improved significantly for counting paths in special classes of graphs.
The notion of Differential Privacy (DP) [12] has emerged as the de facto standard notion for supporting queries on private and sensitive data. DP ensures that changes in private data have limited statistical influence (measured by the privacy budget  $\epsilon, \delta$ ) on the output of queries, without needing any attack model, which is one of the reasons of its popularity. Networked abstractions are commonly used in a number of applications, such as public health, social networks, and finance. Such datasets are usually sensitive, and maintaining privacy is an important concern. Within the context of network/graph data, two privacy models have been considered in most prior work, namely, edge and node privacy. There has been a lot of interest in developing private algorithms for a number of network problems, such as community detection [29, 9, 8, 22], and counting small subgraphs (e.g., stars and triangles [25, 36, 23, 31]).
However, efficient private algorithms with good accuracy are not known for many graph problems, including counting small subgraphs. One of the main challenges is that graph problems often have very high global sensitivity (the maximum change in the output function due to the change in one edge/vertex (see Section 3)), in contrast to many statistical and machine learning queries. As a result, DP algorithms based on global sensitivity (which can usually be computed quite easily for many problems) do not give good accuracy bounds, in general. For instance, in the edge-privacy
model, the global sensitivity of #triangles in a graph  $G = (V,E)$  can be as high as  $n - 2$ , where  $n = |V|$ , making the added noise too large in many instances. A number of novel alternatives to global sensitivity have been proposed, e.g., smooth, restricted and multi-level local sensitivity, and ladder functions [36, 23, 3, 31], which add significantly lower level of noise than mechanisms based on global sensitivity.
However, all these alternative notions of sensitivity are computationally much more challenging, and none of the current graph DP algorithms for subgraph counting scale to even moderate size networks. Even the simplest problem of counting #triangles privately takes  $\min \{m\max_v d(v), M(n)\}$  time [23], where  $m = |E|$ ,  $d(v)$  is the degree of node  $v \in V$ , and  $M(n)$  is the time for multiplying two  $n \times n$  matrices, which is super-quadratic, in general. This is a sharp contrast with the significant advances in non-private graph mining where complex network properties such as clique counts can be computed using provably-efficient and practical algorithms [35, 20, 19]. For a few other subgraphs, such as  $k$ -cliques and  $k$ -triangles (see [36, 23] for definitions), private algorithms using noise lower than the global sensitivity are known, but the worst case running time can still be  $O(n^{k})$  [36]. However, for most subgraph counting problems, no private algorithms which use alternatives to global sensitivity, and have time comparable to the non-private algorithms, are known.
A main tool for subgraph counting and other graph mining tasks in massive networks are sampling based approximation algorithms, e.g., [2]; however, these haven't been used in the context of private graph algorithms. In this paper, we take the first steps in this direction. Our main contributions are:
- We show that for a query  $f(G)$ , we can get a private algorithm by adding noise that scales with an approximation to the smooth sensitivity to an approximation to  $f(G)$  (Theorem 1). This result opens the door to improving efficiency of private algorithms using approximation techniques that have been very useful in non-private graph analytics. As an illustration, we use this result to obtain a quasilinear time private algorithm for counting #triangles under edge privacy (Theorem 2) for graphs which satisfy a stronger transitivity property (see Definition 5). Our algorithm adapts the diamond sampling technique of [2] for approximate triangle counting, and can also be parallelized easily. No parallel algorithms have been developed for private subgraph counting so far.
- Extending the approach of [23], we design a private higher-order local sensitivity approach for subgraph counting, which gives privacy even when the higher-order local sensitivities are estimated approximately (Theorem 7). This yields the first private algorithm to count the number of embeddings of any subgraph with  $\ell$  edges in time  $O(n^{2\ell})$ , using less noise than global sensitivity. For the specific case of paths with  $\ell$  edges, we develop an algorithm that gives a very close approximation to the higher-order sensitivity in time  $O(h(d,t,\ell)poly(n))$ , where  $d$  and  $t$  are the degeneracy and treewidth of  $G$ , respectively (defined later). Thus, for paths, the running time does not grow as  $O(n^{\ell})$  for graphs with bounded degeneracy and treewidth. These properties have been used extensively in developing efficient algorithms for subgraph counting and other graph mining tasks, e.g., [5, 13, 6]; but, they haven't been used for private algorithms.
- We experimentally evaluate our algorithm for counting #triangles (Section 6). We show that our algorithm for estimating the smooth sensitivity has very good approximation factor, and significantly better running time than the exact algorithm. Using approximate smooth sensitivity for counting #triangles gives good accuracy even for fairly low  $\epsilon$  values, suggesting that using approximate smooth sensitivity does not compromise performance. Our algorithm also has good scaling, and is the first private algorithm for counting #triangles which has been run on networks with over 2 million edges.
We note that many details, including proofs are presented in the Supplementary Material (SM).
The area of DP graph algorithms is quite large and active. There has been a lot of work on DP algorithms for many basic graph problems, such as community detection, subgraph counting, finding small cuts, and releasing synthetic graphs [25, 28, 30, 33, 16, 3, 15, 21, 17]. There is some work on graph algorithms under local DP, e.g., [16], but most of the prior work has been for global DP (as defined in Section 3), and is our focus in this work. We refer to [27] for a recent survey on private graph algorithms. For brevity, we only discuss prior work on private subgraph counting that is directly related to our paper, and in the edge-DP model. We omit the discussion on private estimation of edge
Privacy model	Runtime
Global Sensitivity	ε	O(1)
Ladder function [10]	(ε,δ)	Omatrix mul. of size n)
Recursive mechanism [7]	(ε,δ)	O(mn)
Restricted Sensitivity [3]	(ε,δ)	O(mn)
Blackbox Transformation [4]	(ε,δ)	O(non-private #Δ alg.)
(Exact) Smooth Sensitivity [23]	(ε,δ)	Omatrix mul. of size n)
Our method	(ε,δ)	O(m log2n) for (C, Λ)-graphs with constant C, Λ
Table 1: Summary of the characteristics of differentially private #triangle counting algorithms in the edge-privacy model (the other works mentioned here consider other subgraphs also, but we only focus on the runtime of counting #triangles). The runtime of Blackbox Transformation [4] includes the calculation of an approximated triangle counts, while all others assume the true counts are given. The runtime of our method is reported with  $\delta = \Omega(n^{-2})$  and constant  $\gamma$  (see Corollary 1).
density and degree distribution, which has been studied more extensively, e.g., [14], and results for node-DP [25], which is less studied.
As mentioned earlier, global sensitivity, denoted by  $GS(f)$  for a graph metric  $f(G)$  (defined in Section 3) is high for many subgraph counting problems. Adding noise based on  $GS(f)$  leads to low accuracy, while noise based on just  $LS_{f}$ , the local sensitivity, need not be private [31]. Nissim et al. [31] develop the notion of smooth sensitivity  $S_{f,\beta}^{*}(G) = \max_{G'}\left(LS_{f}(G')\cdot e^{-\beta \cdot d(G,G')}\right)$ , where  $d(G,G')$  is the swap distance between graphs  $G$  and  $G'$ , and show that adding noise based on  $S_{f,\beta}^{*}(G)$  is private. However, smooth sensitivity becomes computationally much more challenging, since its definition involves considering local sensitivity at distance  $t$  for all  $t$ , which doesn't seem like a polynomial time computation. Nissim et al. [31] develop polynomial time algorithms for computing the smooth sensitivity exactly for counting #triangles, which was improved slightly to  $\min \{md_{max},M(n)\}$  [23], where  $M(n)$  is the matrix multiplication time. Polynomial time smooth sensitivity bounds were also shown for a small number of other subgraphs, but no polynomial time algorithms are known beyond that. Interestingly, no hardness bounds are known for smooth sensitivity; the existing hardness bounds, e.g., [23, 36] only give hardness for computing local sensitivity at distance  $t$ . In order to handle other subgraph counts, Karwa et al. [23] develop a different technique involving local sensitivity of local sensitivity (motivated by the propose-test-release technique [12]), and use it for private counts of  $k$ -cliques. Zhang et al. [36] develop the technique of ladder functions to handle other kinds of subgraphs, and use it to privately count #k-cliques in the graph in time  $O(nT(n))$ , where  $T(n)$  is the time needed to count #k-cliques non-privately. A few other techniques, such as inverse sensitivity [1] and propose-test-release [12] are known. However, private algorithms for counting most subgraphs including paths and trees are not known. The recent work of [4] is related, but only considers approximation in the queries, but not in sensitivity. As a result, our methods give significantly higher efficiency. We also note that Blocki et al. [4] develop a black-box approach to make certain approximation algorithms differentially private. However, their work requires the function being computed to have "small" global sensitivity.
The difficulty of subgraph counting with DP has motivated work in slight variations of the DP model. Rastogi et al. [34] consider the problems of releasing more general subgraph counts. However, they consider a relaxed version of edge-DP, called (edge) adversarial privacy, that uses a Bayesian attacker. Chen et al. [7] design a different approach that gives lower bounds for general subgraph counts through a linear program to form a recursive strategy. But, as mentioned in [36], their method suffers from a bias between the true query answer and the lower bound, in exchange for less noise. [32] presents a different approach based on iterative refinement that estimates counts by degree, and can be implemented in time  $O((\max_v \deg(v))^3 m)$ .
There have been studies on subgraph counting (including triangle counting) under other privacy models: the node-DP model [25, 10], and the shuffle model [18]. We note that our analysis of approximate smooth sensitivity holds for other privacy models as well, and we expect this could be used for improved private queries for other problems. However, the specific technique using diamond sampling for faster triangle counting only holds in the edge-DP model. Fundamentally new ideas are needed for extending this technique to node-DP and others. For a more comprehensive review of recent development on subgraph counting with privacy, we refer readers to [27].
A non-induced embedding of a graph  $H = (V_H, E_H)$  into a graph  $G = (V, E)$  is a mapping  $\phi : V_H \to V$  such that  $(\phi(u), \phi(v)) \in E$  whenever  $(u, v) \in E_H$ . We use  $f_H(G)$  to denote the number of non-induced embeddings of a  $H$  in  $G$ . We drop the subscript  $H$  when it is clear from the context. Let  $\ell = |V_H|$  and  $n = |V|$ .  $A$  denotes the adjacency matrix of graph  $G$ . Let  $N(i)$  and  $\overline{N(i)}$  denote the set of neighbors and non-neighbors of node  $i \in V$ , respectively; let  $d(i) = |N(i)|$  and  $\bar{d}(i) = n - 1 - d(i)$ . Let  $d_{\max} = \max_{v \in V} d(v)$  denote the maximum degree.
Differential privacy on graphs. Let  $\mathcal{G}$  denote a set of graphs on a fixed set  $V$  of nodes. For a graph  $G \in \mathcal{G}$ , we use  $V(G)$  and  $E(G)$  to denote the set of nodes and edges of  $G$ , respectively. In this paper, we will focus on the notion of edge privacy [3], where all graphs  $G \in \mathcal{G}$  have a fixed set of nodes  $V(G) = V$ , and two graphs  $G, G' \in \mathcal{G}$  are considered neighbors, i.e.,  $G \sim G'$ , if they differ in exactly one edge, i.e.,  $|E(G) - E(G')| = 1$ .
Definition 1. A (randomized) algorithm  $M: \mathcal{G} \to R$  is  $(\epsilon, \delta)$ -differentially private if for all subsets  $S \subset R$  of its output space, and for all  $G, G' \in \mathcal{G}$ , with  $G \sim G'$ , we have  $\text{Pr}[M(G) \in S] \leq e^{\epsilon} \text{Pr}[M(G') \in S] + \delta$  [12, 3].
Problem statement: subgraph counting with edge differential privacy. Given a family of graphs  $\mathcal{G}$  on a set  $V$  of vertices, a subgraph  $H$ , and parameters  $\epsilon, \delta$ , construct an  $(\epsilon, \delta)$ -differentially private mechanism  $M_{f_H} : \mathcal{G} \to 2^V$ , such that  $|M_{f_H}(G) - f_H(G)|$  is minimized.
We discuss the notions of sensitivity mostly using the notation from [23, 31], with slight changes. Let  $LS_{f}(G) = \max_{G^{\prime}\sim G}|f(G) - f(G^{\prime})|$  denote the local sensitivity of  $f$ ; we also use  $LS(f(G))$  to denote this.  $GS(f) = \max_{G}LS(f(G))$  denotes the global sensitivity. The local sensitivity of a function  $f$  on a graph  $G$  at distance  $t$  is defined as  $LS_{f}^{(t)}(G) = \max_{d(G,G^{\prime})\leq t}LS_{f}(G^{\prime})$
Definition 2. (Smooth bound on  $LS$  [31]) For  $\beta >0$ , a function  $S:D^n\to \mathbb{R}^+$  is a  $\beta$ -smooth upper bound on  $LS_{f}$  if it satisfies the following conditions: (1) for all  $x\in D^{n}$ :  $S(x)\geq LS_{f}(x)$ , and (2) for all  $x\sim y\in D^n$ :  $S(x)\leq e^{\beta}\cdot S(y)$ .
$S_{f,\beta}^{*}(G) = \max_{G^{\prime}}(LS(f(G^{\prime}))\cdot e^{-\beta d(G,G^{\prime})})$  is the smallest function satisfying Definition 2, and is referred to as the  $\beta$ -smooth sensitivity of  $f$  at  $G$ . Using the local sensitivity at distance  $t$ , the smooth sensitivity can be written as  $S_{f,\beta}^{*}(G) = \max_{t = 1,\dots ,\binom{n}{2}}e^{-t\beta}LS_{f}^{(t)}(G)$ .
Definition 3. (Admissible Noise Distribution) [31] A probability distribution on  $\mathbb{R}^d$  given by a density function  $h$  is  $(\alpha, \beta)$ -admissible if, for  $\alpha = \alpha(\epsilon, \delta)$ ,  $\beta = \beta(\epsilon, \delta)$ , the following conditions hold for all  $\Delta \in \mathbb{R}^d$  and  $\lambda \in \mathbb{R}$  satisfying  $||\Delta||_1 \leq \alpha$  and  $|\lambda| \leq \beta$ , and for all measurable  $S \subseteq \mathbb{R}^d$ : (1) Sliding property:  $\operatorname{Pr}_{Z \sim h}[Z \in S] \leq e^{\epsilon/2} \operatorname{Pr}_{Z \sim h}[Z \in S + \Delta] + \delta/2$ , and (2) Dilation property:  $\operatorname{Pr}_{Z \sim h}[Z \in S] \leq e^{\epsilon/2} \operatorname{Pr}_{Z \sim h}[Z \in e^\lambda \cdot S] + \delta/2$ .
An important example of an admissible noise distribution is the Laplace mechanism  $Lap(\lambda)$  probability density function is  $h(z) = \frac{1}{2\lambda} e^{-|z| / \lambda}$ .
Lemma 1. (Calibrating noise to Smooth Sensitivity [31]) Let  $Z$  be a random variable sampled from an  $(\alpha, \beta)$ -admissible noise. Let  $S_{f,\beta}$  be the  $\beta$ -smooth upper bound on the local sensitivity of  $f$ . Then algorithm  $A(x) = f(x) + \frac{S_{f,\beta}(x)}{\alpha} Z$  is  $(\epsilon, \delta)$ -differentially private.
Definition 4. (An  $(\alpha, \delta)$ -approximation to a function  $f$ ).  $\tilde{f}$  is said to be an  $(\alpha, \delta)$ -approximation to a function  $f$  if for any input  $x$ , with probability at least  $1 - \delta$ , we have  $(1 - \alpha)f(x) \leq \tilde{f}(x) \leq (1 + \alpha)f(x)$ .
Social networks generally have the property that nodes have high clustering coefficient, which is the fraction of pairs of neighbors of a node which are connected. We consider a more restricted notion here. We refer to a path with  $r$  edges as an  $r$ -path. We say a 2-path  $i,j,k$  is "closed" if  $(i,k) \in E$ , i.e.,  $i,j,k$  form a triangle in  $G$ .
Definition 5.  $((C, \Lambda)$ -transitive graph) A graph is said to be  $(C, \Lambda)$ -transitive if for any vertex  $j \in V$  and edge  $(i, j) \in E$ , we have: if  $\deg(j) > \Lambda$ , then  $C$  fraction of all the 2-paths starting with  $i, j$  are closed.
4 Approximate smooth sensitivity and fast private triangle counting
We first show that we can ensure privacy even if the smooth sensitivity  $S_{f,\beta}^{*}$  is estimated approximately; we then extend it to show that this works when  $f(G)$  and  $S_{f,\beta}^{*}$  both are estimated approximately.
Definition 6.  $\tilde{S}_{f,\beta}$  is said to be a  $\gamma$ -upper approximation of the smooth sensitivity  $S_{f,\beta}^{*}$  of function  $f$  if  $S_{f,\beta}^{*}(D)\leq \tilde{S}_{f,\beta}(D)\leq e^{\gamma}S_{f,\beta}^{*}(D)$  for any dataset  $D$ .  $\tilde{S}_{f,\beta}$  is said to be a  $(\gamma, \delta')$ -upper approximation of the smooth sensitivity  $S_{f,\beta}^{*}$  of function  $f$  if  $\tilde{S}_{f,\beta}$  is a  $\gamma$ -upper approximation for any dataset  $D$  with probability at least  $1 - \delta'$ .
We observe below that calibrating noise using a  $(\gamma, \delta')$ -approximation of the smooth sensitivity gives us privacy. We assume  $f$  is a real valued function, since we are focused on graph statistics.
Lemma 2. (Lemma 12) Let  $\tilde{S}_{f,\beta}$  be a  $(\gamma, \delta')$ -approximation to  $S_{f,\beta}^{*}$ , for  $\gamma = \beta = \frac{16\epsilon}{\ln(2 / \delta)}$ . Then,  $A(D) = f(D) + \operatorname{Lap}\left(\frac{2\tilde{S}_{f,\beta}(D)}{\epsilon}\right)$  is  $(\epsilon, \frac{e^{\epsilon / 2} + 1}{2}\delta + 2\delta')$ -differentially private.
Approximate Smooth Sensitivity for Approximate Query. We now show that approximate smooth sensitivity can be used even when  $f(G)$  is computed approximately, which becomes a bit more challenging.
Let  $A_{f}$  be  $(\alpha_{1},\delta_{1})$ -approximation of a function (query)  $f$  for a small constant  $\alpha_{1} < 1 / 2$ . Let  $\tilde{S}_{f,\beta}$  be  $(\gamma ,\delta_2)$ -upper approximation to  $S_{f,\beta}^{*}$ . We will show that we can utilize  $A_{f}$  and  $\tilde{S}_{f,\beta}$  to calculate a differentially private version of the function  $f$ .
For the purpose of privacy analysis, we define the functions  $g_{f}$ ,  $s_{f}$ , and  $S_{g_f}$  as below. Those functions may not be computed efficiently. However, they are only used for the analysis, and the actual algorithm does not compute them. The actual computation (Algorithm 3) will only utilize  $A_{f}$  and  $\tilde{S}_{f,\beta}$  to output the differentially private version of  $f$ . We follow some of the analysis of [4] to prove our privacy guarantees below. We share (with [4]) the same process of proving that  $S_{g_f}(D)$  is a smooth-upper bound of the local sensitivity (Smooth Sensitivity) of  $g_{f}$ . The main difference is our analyses has to take into account the newly defined function  $s_f$ -which is a bounded variant of the Approximate Smooth Sensitivity ( $\tilde{S}_{f,\beta}$ , which approximates  $S_{f,\beta}^{*}$ ), while [4] uses the global sensitivity  $GS_{f}$  of  $f$ . As we can see in Lemma 13, the second condition requires  $S_{g_f}(D) \leq e^{\beta'} S_{g_f}(D')$  for any pair of neighbor datasets  $D \sim D'$ . While  $GS_{f}$  remains unchanged in both  $D$  and  $D'$ ,  $\tilde{S}_{f,\beta}$  may have different values for  $D$  and  $D'$  which makes it more difficult to analyze  $S_{g_f}$ . We also have to take into account the small probability  $\delta_2$  that  $\tilde{S}_{f,\beta}(D) \notin \{S_{f,\beta}(D), e^{\gamma} S_{f,\beta}(D)\}$ , that will add up in the  $\delta$ -part of  $(\epsilon, \delta)$ -DP of the final output.
Definition 7. Let  $A_{f}$  be an  $(\alpha_{1},\delta_{1})$ -approximation of  $f$ . We define functions  $g_{f}$  and  $s_f$  as:
$$
g _ {f} = \left\{ \begin{array}{l} A _ {f} (D) \text {i f} (1 - \alpha_ {1}) f (D) \leq A _ {f} (D) \leq (1 + \alpha_ {1}) f (D), \\ (1 - \alpha_ {1}) f (D) \text {i f} A _ {f} (D) <   (1 - \alpha_ {1}) f (D), \\ (1 + \alpha_ {1}) f (D) \text {i f} A _ {f} (D) > (1 + \alpha_ {1}) f (D). \end{array} \right. \tag {1}
$$
$$
s _ {f} = \left\{ \begin{array}{l} \tilde {S} _ {f, \beta} (D) \text {i f} S _ {f, \beta} (D) \leq \tilde {S} _ {f, \beta} (D) \leq e ^ {\gamma} S _ {f, \beta} (D), \\ S _ {f, \beta} (D) \text {i f} \tilde {S} _ {f, \beta} (D) <   S _ {f, \beta} (D), \\ e ^ {\gamma} S _ {f, \beta} (D) \text {i f} \tilde {S} _ {f, \beta} (D) > e ^ {\gamma} S _ {f, \beta} (D). \end{array} \right. \tag {2}
$$
Let  $S_{g_f}(D) = 4\alpha_1 g_f(D) + 2s_f(D)$
Lemma 3. (Lemma 13) Given  $g_{f}$ ,  $s_{f}$ , and  $S_{g_{f}}$  as defined above,  $S_{g_{f}}$  is a  $\beta'$ -smooth upper bound of the local sensitivity of  $g_{f}$ , where  $\beta' \geq 4\alpha_{1} + \gamma + \beta$  and  $\alpha_{1} < 1/2$ .
In order to prove that  $S_{g_f}$  is a  $\beta'$ -smooth upper bound of the local sensitivity of  $g_f$ , we have to prove the two conditions:  $LS_{g_f}(D) \leq Sg_f(D)$ , and  $S_{g_f}(D) \leq e^{\beta'}S_{g_f}(D')$  for any pair of neighbor datasets  $D \sim D'$ . The full proof is in Lemma 13 in the SM. Theorem 1 below summarizes our result.
Theorem 1. (Theorem 4) Let  $A_f$  be a  $(\alpha_1, \delta_1)$ -approximation to  $f$ ,  $\tilde{S}_{f,\beta}$  be a  $(\gamma, \delta_2)$ -upper approximation to  $S_{f,\beta}^*$ , for  $\gamma = \beta = \frac{8\epsilon}{\ln(2 / \delta)}$ ,  $\alpha_1 = \frac{4\epsilon}{\ln(2 / \delta)}$ . Then,  $A(D) = A_f(D) + \text{Lap}\left(\frac{8\alpha_1A_f(D) + 4\tilde{S}_{f,\beta}(D)}{\epsilon}\right)$  is  $(\epsilon, \frac{e^{\epsilon / 2} + 1}{2}\delta + 2\delta_1 + 2\delta_2)$ -differentially private.
4.1 Application: fast private triangle counting
In this section, we study the problem of computing  $f_{\Delta}(G)$ , the number of triangles in a graph  $G(E,V)$ , by fast approximation of its smooth sensitivity. Recall the definitions of local sensitivity at distance  $t$ , denoted by  $LS_f^{(t)}(G)$ , defined in Section 3.
We denote the local and smooth sensitivity of  $f_{\Delta}(G)$  by  $LS_{\Delta}^{(t)}(G)$  and  $S_{\Delta,\beta}^{*}(G)$ .