SlowGuess/NeurIPS_2023_OCR huggingface dataset:
Let  $a_{ij} = \sum_{k\in [n]}A_{ik}A_{jk}$  denote the number of common neighbors of nodes  $i$  and  $j$  in a graph and  $b_{ij} = \sum_{k\in [n]}A_{ik}\oplus A_{jk}$  denote the number of nodes that are neighbors of  $i$  or  $j$  but not both. Then it has been shown that  $LS_{\Delta}^{(t)}(G) = \max_{i,j}c_{ij}(t)$  where  $c_{ij}(t) = \min \left(a_{ij} + \frac{t + \min(t,b_{ij})}{2},n - 2\right)$  (Claim 3.13 of [31]).
We can rewrite this as  $LS_{\Delta}^{(t)}(G) = \min \left(\max_{i,j}\left(a_{ij} + \frac{b_{ij}}{2} +\frac{t}{2}\right),\max_{i,j}a_{ij} + t,n - 2\right)$ .
Figure 1: Paths  $(i,k,j)$  and  $(i,o,j)$  represent wedges formed by nodes  $i,j$  [2].
The bottleneck in computing  $LS_{\Delta}^{(t)}(G)$  (and  $S_{\Delta, \beta}^*(G)$ ) is estimating  $\hat{a} = \max_{i,j} a_{ij}$ . We adapt the diamond sampling technique of [2] for this task. By doing that, we can quickly calculate  $\widehat{LS}_{\Delta}^{(t)}(G) = \min(\max_{i,j} \frac{\deg(i) + \deg(j)}{2} + \frac{t}{2}, \hat{a} + t, n - 2)$ . The core idea in diamond sampling is to find a "diamond" (a 4-cycle) of the form  $(i, o, j, k)$  obtained by the intersection of two "wedges" (a 2-path  $(i, o, j)$  and  $(i, k, j)$ , as shown in Figure 1. Since any pair  $(i, j)$  is part of  $a_{ij}^2$  diamonds, the probability of selecting such a diamond is proportional to  $a_{ij}^2$ . This idea is formalized in Algorithm 4. Let
$W$  be the matrix  $W_{ki} = deg(k)\times deg(i)$  for all  $(k,i)\in E$ , and 0 for all other entries.
We first note that if  $\hat{a} = 0$ , it must be the case that  $G$  has no paths of length  $\geq 2$ , for if there is a 2-path  $i, k, j$ , then  $a_{ij} \geq 1$ . Therefore, if  $\hat{a} = 0$ , we can determine  $LS_{\Delta}^{(t)}(G)$  exactly in time  $O(m)$ . Therefore, we assume that  $\hat{a} \geq 1$  in the rest of this section.
Even though Algorithm 4 can quickly estimate the quantity  $\max a_{ij}^{2}$  within a specific bound, it can only do so with the number of iterations that is sufficiently large—which its exact threshold is unknown without the access to the dataset and the value of interest  $(\max a_{ij}^{2})$  itself (see Lemma 15).
We overcome this issue with the following idea. First, we propose some estimation  $\tau$  of  $\max a_{ij}^2$  and run an instance of Algorithm 4 with the number of iterations computed from  $\tau$ . Second, we compare the estimation of  $\max a_{ij}^2$  returned by Algorithm 4 with  $\tau$  to determine if we over- or under-estimate  $\tau$ . Third, we adjust  $\tau$  accordingly and repeat the process until we find a good value of  $\tau$ .
Algorithm 1 τ estimation
Input: G(E,V)
Output: τ < max_ij a_ij^2	Algorithm 2 Algorithm to compute ŜΔ,β(G)
Input: G(E,V),β,δ,γ
Output: ŜΔ,β(G)
1: k := 0, τk := n^2, θ := 1/2	1: τk := Algorithm 1(G)
2: while TRUE do	2: τ := τk/3
3: Calculate s := 3c log n||W||/θ²τk	3: θ := e^2γ-1/e^2γ+1
4: x := Algorithm 4(G,s)	4: c := max(log_n(1/(2δ))+2,12θ^2)
5: if max_ij x_ij∥W∥s < 3/2 τk then	5: Calculate s := 3c log n||W||/θ^2τ
6: τk+1 := 3/4 τk	6: x := Algorithm 4(G,s)
7: k := k+1	7: a^2 := max_ij x_ij∥W∥s/1-θ
8: else	8: Calculate LŜΔ(t)(G), t=1,...,log(n)/β, using a
9: Return τk	9: Return max_t=1,...,log(n)/β e^-tβ LŜΔ(t)(G)
10: end if
11: end while
We implement Algorithm 1 based on this idea. In the algorithm, we first set  $\tau$  to its largest possible value  $(n^2)$  knowing that we are over-estimating  $\tau$  ( $\tau > \max a_{ij}^2$ ). We note that by over-estimating  $\tau$ , Algorithm 4 (line 6) may not have enough iterations to guarantee the convergence of  $\max x_{ij}$  to  $\max a_{ij}^2$ . Note that in the output of Algorithm 4, for any  $i,j$ ,  $x_{ij}$  is an approximation of  $a_{ij}^2$ . We
determine if we are truly over-estimating  $\tau$  by applying Corollary 3 (in the SM), comparing the estimation  $\max_{ij} x_{ij}$  from Algorithm 4 in line 6 to  $(3/2)\tau$ . The proof utilizes an idea that even though  $\max_{ij}$  may not converge to  $\max a_{ij}^2$  and we may not determine it directly,  $\max_{ij}$  can converge to  $\tau$  once we under-estimate  $\tau$  (i.e.,  $\tau < \max a_{ij}^2$ ) and that we can check this convergence easily. Corollary 3 states that when  $\max_{ij} x_{ij} < (3/2)\tau$ ,  $\max a_{ij}^2 < 3\tau$  which means we should lower  $\tau$ . We keep running Algorithm 4 and reducing  $\tau$  by  $3/4$  in each iteration until the estimation of  $\max_{ij}$  lies above  $(3/2)\tau$ . By Corollary 3, we show that when it happens,  $\tau_k \leq \max a_{ij}^2$  that guarantees the convergence of  $\max_{ij}$  to  $\max a_{ij}^2$ . Lemma 4 shows that when the algorithm outputs  $\tau_k$ , w.h.p., the true value of interest  $\max a_{ij}^2$  is within  $\tau_k$  and  $4\tau_k$ .
Lemma 4. (Lemma 18 in SM) Let  $\tau_{k}$  be the output of Algorithm 1. With probability at least  $1 - 1 / n^{c - 3}$ ,  $\tau_{k} < \max_{ij}a_{ij}^{2} < 4\tau_{k}$ .
Algorithm 2 calculates an approximation of  $\max a_{ij}^2$  for the Approximated Smooth Sensitivity with any  $\gamma$  (which is required for Differential Privacy with an arbitrary  $\epsilon$ ). Since  $\tau_k$  is guaranteed to be close to the true value of  $\max a_{ij}^2$  (within a constant factor of 4), we run the last instance of Algorithm 4 with some constant  $\theta$ , which is derived from the target approximation factor  $\gamma$ . Lemma 5 shows that the estimation output by Algorithm 4 in line 6 falls within the range of  $(1 - \theta, 1 + \theta)$  of the true value. Following that, Theorem 2 guarantees that the quantity output by Algorithm 2 is a  $(\gamma, \delta)$ -upper approximation to Smooth Sensitivity  $S_{\Delta, \beta}(G)$  of the triangle count of graph  $G$ .
Lemma 5. (Lemma 19 in SM) With probability at least  $1 - \delta$  in Algorithm 2,  $\max_{ij} x_{ij} \frac{\|W\|}{s} \in (1 - \theta, 1 + \theta) \max_{ij} a_{ij}^2$ .
Theorem 2. (Theorem 5, 6 in SM) Suppose  $\max_{ij} a_{ij} > 0$ . Algorithm 2 outputs  $\tilde{S}_{\Delta,\beta}(G)$ , which is  $a(\gamma, \delta)$ -upper approximation to  $S_{\Delta,\beta}(G)$ , in  $O\left(\frac{\log_n \left( \frac{1}{2\delta} \right) \|W\|_1 \log m \log n}{\left( \frac{e^{2\gamma} - 1}{e^{2\gamma} + 1} \right)^2 \max_{ij} a_{ij}^2} + m + \frac{\log n}{\beta} + n\right)$  time.
Proof. (Sketch) Algorithm 1 has a run-time of  $kO(s' \log m)$  where  $s' = O(\| W \|_1 c \log n / (\theta^2 \tau))$  as it executes Algorithm 4 with varying  $s = s'$  and  $k$  is the number of search steps. Since at the end of the search  $\tau_k > \max_{ij} a_{ij}^2 / 4$  w.h.p., we know that  $k = O(\log \frac{4n^2}{\max_{ij} a_{ij}^2})$ . In the first step, we start with  $\tau_0 = n^2$  and reduce  $\tau_k$  by a factor of  $3/4$  after each step. The total running time will be  $O(\| W \|_1 \times \log m \times \frac{c \log n}{\theta^2} \times \frac{1}{n^2} (1 + (3/4)^{-1} + \dots (3/4)^{-k}) = O\left(\frac{\|W\|_1 c \log m \log n}{\theta^2 \max_{ij} a_{ij}^2}\right)$ . Finally, Algorithm 2 has a run-time of  $O\left(\frac{\log_n (2\delta) \|W\|_1 \log m \log n}{\left(\frac{e^{2\gamma} - 1}{e^{2\gamma} + 1}\right)^2 \max_{ij} a_{ij}^2} + m + \frac{\log n}{\beta} + n\right)$  taking into account the time required to compute  $W(O(m))$  and  $\tilde{S}_{\Delta,\beta}(G)$  ( $O(\log (n) / \beta + n)$ ) and substituting the values of  $c$  and  $\theta$  as described in the Algorithm.
Corollary 1. Suppose  $\max_{ij} a_{ij} > 0$ ,  $G$  is  $(C, \Lambda)$ -transitive (as in Definition 5), and  $\delta \geq n^{-2}$ . Then, for any parameter  $\gamma > 0$ . Algorithm 2 outputs  $S_{\Delta, \beta}(G)$ , which is a  $(\gamma, \delta)$ -upper approximation to  $S_{\Delta, \beta}(G)$ , in  $O(m \max(1/C^2, \Lambda^2)) \log m \log n / \min(\gamma^4, 1/4) + n)$  time.
Proof. Since  $\left(\frac{e^{2\gamma} - 1}{e^{2\gamma} + 1}\right)^2 > \gamma^4$  for  $0 < \gamma < 1/\sqrt{2}$ , we have  $\left(\frac{e^{2\gamma} - 1}{e^{2\gamma} + 1}\right)^2 > \min(\gamma^4, 1/4)$ . Next, for any node  $i$  and  $j \in \mathcal{N}_i$ , we have  $\frac{\deg(j)}{\max_{i'j'} a_{i'j'}} \leq \max \left\{\frac{1}{C}, \Lambda\right\}$ : if  $\deg(j) > \Lambda$ , it must be the case that at least  $C$ -fraction of the paths  $i, j, k$  for  $k \in \mathcal{N}_j$  are closed, which means  $a_{ij} \geq C \cdot \deg(j)$ , and so  $\frac{\deg(j)}{\max_{i'j'} a_{i'j'}} \leq \frac{1}{C}$ ; if  $\deg(j) \leq \Lambda$ , we have  $\frac{\deg(j)}{\max_{i'j'} a_{i'j'}} \leq \Lambda$ . Therefore,  $\frac{\|W\|}{\max_{ij} a_{ij}^2} = \sum_{i \in V(G)} \sum_{j \in \mathcal{N}_i} \frac{\deg(i) \times \deg(j)}{\max_{i'j'} a_{i'j'}^2} = \sum_{i \in V(G)} \frac{\deg(i)}{\max_{i'j'} a_{i'j'}} \sum_{j \in \mathcal{N}_i} \frac{\deg(j)}{\max_{i'j'} a_{i'j'}} \leq \sum_{i \in V(G)} \sum_{j \in \mathcal{N}_i} \frac{\deg(i)}{\max_{i'j'} a_{i'j'}} = 2m\max (\frac{1}{C^2}, \Lambda^2)$ , the Corollary follows.
5 Higher-order local sensitivity and improved bounds for path counting
As mentioned earlier in Section 2, Karwa et al. [23] develop a different technique involving local sensitivity of the local sensitivity, and use it for private counts of  $k$ -cliques, since it seems hard to
Figure 2: Examples of compact subgraphs and anchor edges in the algorithm for computing higher-order sensitivity of paths: (Left)  $D = \{r_1, r_2, r_3, r_4\}$ , edges  $(r_1, r_1')$ ,  $(r_2, r_2')$ ,  $(r_3, r_3')$  and  $(r_4, r_4')$  are external anchor edges, while  $(r_5, r_5')$  is an internal anchor edge. Nodes  $s$  and  $t$  are the starting and ending nodes of the path; (Middle)  $D = \{r_1, r_2, r_3\}$ , and  $(r_1, r_1')$ ,  $(r_2, r_2')$ ,  $(r_3, r_3')$  are external anchor edges, while  $(r_5, r_5')$  is an internal anchor edge. Node  $s$  is the starting node of the path, and the path ends at some other node, not in this compact subgraph; (Right)  $D = \{r_1, r_2, r_3, r_4\}$ , edges  $(r_1, r_1')$ ,  $(r_2, r_2')$ ,  $(r_3, r_3')$  and  $(r_4, r_4')$  are external anchor edges, while  $(r_5, r_5')$  and  $(r_6, r_6')$  are internal anchor edges. Paths pass through this compact subgraph, without starting or ending in it.
estimate smooth sensitivity for such subgraphs. We generalize it, and develop a multi-level local sensitivity approach, extending [23], for privately counting the number of copies of any subgraph  $H$ ; as in the case of smooth sensitivity, we show that this also works with approximate queries.
Let  $\ell$  denote the number of edges in  $H$ . Our main idea involves finding private bounds for higher-order local sensitivity. Let  $L = \{\{i,j\} : i,j \in V\}$  denote all possible pairs of nodes in  $V$ . For subgraph  $H$ , and a subset  $S \subset \{\{i,j\} : i,j \in V\}$  of pairs of nodes, let  $f_{H}(G,S)$  denote the number of embeddings of  $H$  in the graph  $G(V,E \cup S)$ , which contain all the edges corresponding to pairs of nodes in  $S$ . For  $S = \emptyset$ ,  $f_{H}(G,\emptyset)$  is the number of embeddings of  $H$  in  $G$ . We drop the subscript  $H$  when it is clear from the context. Let  $f^{(k)}(G) = \max_{|S| = k} f(G,S)$ ; note that  $f^{(0)}(G) = f(G)$ . It can be seen that  $LS(f^{(k)}) \leq f^{(k + 1)}(G)$ , which is the basis for considering higher-order local sensitivity for subgraph counting. However, a careful analysis of the privacy bounds becomes involved. Our approach is described in Algorithm 5 in the supplementary material, and the main result is summarized below.
Theorem 3. Let  $g^{(k)}(G) = f^{(k)}(G) + g^{(k+1)}(G)\frac{\ln 1 / \delta_2}{\epsilon_2} + \text{Lap}(g^{(k+1)}(G) / \epsilon_2)$ , for  $k = \ell - 1, \dots, 0$  as computed in Algorithm 5. Then,  $g^{(0)}(G)$  is an  $((k_m + 1)\epsilon_2, \delta_2 + (k_m + 1)e^{\epsilon_2}\delta_2)$ -DP estimate of  $f(G)$ .
The above result, and the definition of  $f^{(k)}(G)$  implies that for any subgraph with  $\ell$  edges, the higher-order local sensitivity approach can be run in time  $O(n^{2\ell})$ . This can be improved further for paths and trees, as summarized below.
Lemma 6. Private counting for a graph  $H$  with a constant  $\ell$  number of edges using higher-order local sensitivity (Algorithm 5) has running time  $O(n^{2\ell})$ . When  $H$  is a path or tree with  $\ell$  edges, Algorithm 5 has running time  $O(n^{\ell +1})$ .
Higher-order local sensitivity with approximate queries. We show that our method works even if we have a very good approximation  $\hat{f}(x)$  to  $f(x)$ , instead of the exact value (Theorem 7 in the supplementary material). This allows us to use  $\hat{f}(x)$  instead of  $f(x)$  in Algorithm 5.
Improved bounds for path counting in graphs with bounded degeneracy and treewidth. We say that  $G$  has degeneracy  $d$ , if the nodes can be ordered so that each node has at most  $d$  neighbors with higher index [13]. Informally,  $G$  has treewidth  $t$  if it has recursive balanced separators of size  $t$ ; see [11] for details. There has been a lot of work showing that non-private algorithms for subgraph counting can be done efficiently when  $G$  has either of these parameters bounded, e.g., [5, 13, 6, 11]. We show that if  $G$  has degeneracy  $d$  and treewidth  $t$ , then the higher-order local sensitivity of paths of length  $k$  can be computed in time  $O(h(d, t, k)\mathrm{poly}(n))$ , where  $h(d, t, k)$  is independent of  $n$ ; thus the running time does not scale as  $n^k$ .
Our algorithm and analysis are summarized in Section E in the supplementary material (Theorem 8). Recall that the goal is to compute  $f^{(k)}(G) = \max_{S:|S|\leq k}f(G,S)$ . We summarize the main ideas here. We show that a feasible solution, which involves fixing a subset  $S$  of pairs of nodes, can be viewed as a tuple of at most  $k$  disjoint subgraphs  $(H_i,D_i)$ , referred to as  $k$ -compact subgraphs. This is
Network	Description	#nodes	#edges	#triangles
Oregon-1	AS peering information-Oregon route-views	10,670	22,002	17,145
ca-HepTh	Collaboration network-Arxiv High Energy Physics	9,877	51,971	28,339
ca-GrQc	Collaboration network-Arxiv General Relativity	5,242	14,496	48,620
Oregon-2	AS peering information-Oregon route-views	10,900	31,h180	82,857
ca-CondMat	Collaboration network-Arxiv Condensed Matter	23,133	186,936	173,361
loc-Brightkite	Brightkite location based online social network	58,228	428,156	494,728
com-Amazon	Amazon product network	334,863	925,872	667,129
email-Enron	Email communication network- Enron	36,692	367,662	727,044
ca-AstroPh	Collaboration network-Arxiv Astro Physics	18,772	198,110	\( 1.35 \times 10^6 \)
com-DBLP	DBLP collaboration network	317,080	2,099,732	\( 2.22 \times 10^6 \)
loc-Gowalla	Gowalla location based online social network	196,591	950,327	\( 2.27 \times 10^6 \)
ca-HepPh	Collaboration network-Arxiv High Energy Physics	12,008	237,010	\( 3.36 \times 10^6 \)
Table 2: Statistics of tested networks.
defined to be a subgraph which satisfies the following conditions (Figure 6): (1)  $H = G_{\sigma}(v, k, F^{(i)})$  for some node  $v$  and subset  $F^{(i)} = \{e_1, \ldots, e_i\}$ , where  $G_{\sigma}$  is the  $k$ -hop graph starting at node  $v$ , only restricted to higher degeneracy order nodes than  $v$ , (2) the  $k$ -hop neighborhood is expanded as edges in  $F^{(i)}$  (referred to as internal anchor edges) are added, one at a time, and (3)  $D$  is a subset of vertices in  $H$ , and is referred to as the set of connectors. The compact subgraphs are connected via edges between connector nodes.
We show that paths using edges from  $S$  (which contribute to the count  $f(G, S)$ ) can be viewed to consist of segments within these compact subgraphs, passing through internal anchor edges, as well as edges between connectors (which are also from  $S$ ). We guess the number of path segments between connectors within a factor of  $(1 + 1 / (\log n)^c)$  for a constant  $c$ , which allows us to search for a tuple of compact subgraphs with the corresponding approximate counts. We show that the number of such tuples is  $O(h(d, k)poly(n))$ , and existence of given tuple can be determined in a similar time.
We evaluate our algorithm for privately computing #triangles using approximate smooth sensitivity (Algorithm 2), compared with the exact version of smooth sensitivity and other baselines.
Datasets. We consider different real-world networks from [26] as inputs. The networks have sizes range from  $10K - 300K$  nodes, with one of the largest ones having over 2 million edges. Statistics of the networks are presented in Table 2. Due to space limit, we only present the results for some selected networks here. The full results are presented in the SM.
Infrastructure. All algorithms are implemented in C++ and OpenMP framework for parallelization. We ran our experiments on a system with a 48-core Intel(R) Xeon(R) Gold 6248R CPU @ 3.00GHz and 1.5TB RAM and limit the number of parallel threads in all experiments to 40.
Baselines. We implement two baseline methods: the exact smooth sensitivity of triangle count to calibrate Laplacian noise (denoted in our experiment as Karwa et al.) [23], and using the ladder function method (Zhang et al.) [36].
Metrics for evaluating performance. For each input network  $G$ , we calculate the following metrics:
- Accuracy of the private triangle counts, defined as TRIANGLE COUNT RELATIVE ERROR =  $\frac{|M_{f_{\Delta}}(G) - f_{\Delta}(G)|}{f_{\Delta}(G)}$ , where  $M_{f_{\Delta}}$  is the tested private mechanism to output  $f_{\Delta}(G)$ .
- Speedup of Algorithm 2, which compares its running time with the time required for [36, 23]  
 $\mathrm{SPEEDUP} = \frac{\mathrm{Runtime~of~our~algorithm~on~}G}{\mathrm{Runtime~of~baseline~algorithm~on~}G}$  (Figure 5).
- Approximation error of Algorithm 2 for estimating smooth sensitivity, defined as SENSITIVITY APPROXIMATION ERROR =  $\frac{\tilde{S}_{\beta}(G) - S_{\beta}(G)}{S_{\beta}(G)}$  (Figure 4).
Parameters. We test our algorithms at different privacy budgets  $\epsilon \in \{2^{\{-3, -2, -1, 0, 1\}}\}$  and a fixed  $\delta = 10^{-6}$ . We report the average accuracy and runtime of five (5) repeats of the private triangle count via approximate smooth sensitivity experiments due to the randomness used in the algorithm. For the exact calculation, we calculate the smooth sensitivity once and re-sample the noise in each run, since
the exact calculation of the sensitivity is deterministic and does not change for each setting. We use the true counts of triangles of the networks as reported by [26].
Figure 3: Triangle Count Relative Error, showing the accuracy of the private triangle count with noise calibrated by (1) our approximate smooth sensitivity (Algorithm 2), (2) the exact smooth sensitivity (Karwa et al.), and (3) the ladder function (Zhang et al.)
Figure 4: Error factor in approximate smooth sensitivity output by Algorithm 2 (relative to the exact smooth sensitivity) on selected networks. Dotted lines indicate the theoretical upper bound factor  $e^{\gamma}$  (guaranteed by Theorem 2).
Experimental Results. The results show that our algorithm can achieve similar levels of accuracy to the exact calculation while being several orders of magnitude faster. Figure 3 shows that when using approximate smooth sensitivity, the private triangle counts reach the accuracy of using the exact calculation of the smooth sensitivity across different privacy budgets in all but two networks (Oregon 1 and Oregon 2). In these two networks, the smooth sensitivities are relatively large in comparison with the triangle counts, which makes the noise fluctuate more for the approximate estimate (see Figure 8).
Figure 5: Speedup of Algorithm 2 over the exact smooth sensitivity (Karwa et al.), and the ladder
Figure 4 shows that all approximate smooth sensitivities are within some small factor of the exact smooth sensitivities. Noter that approximate smooth sensitivities are always larger than the true smooth sensitivity. It is important since a lower value may expose the privacy due to an inadequate noise magnitude. In general, a smaller value of  $\epsilon$  (higher privacy guarantee) requires a more accurate estimation of the sensitivity. It is illustrated in Figure 4 as the approximate smooth sensitivity is close to the exact smooth sensitivity in all networks at  $\epsilon = 0.125$  or  $\epsilon = 0.25$ .
Figure 5 shows that our approximation algorithm is orders of magnitude faster than the exact algorithm. In large graphs (Amazon, DBLP, Gowalla), the speedup may reach 1,000-fold. Generally, a lower  $\epsilon$  requires a smaller approximation factor  $(\gamma)$ , which in turn requires a larger number of iterations to reduce the error in approximation. The majority of tested networks have speedup factors between 10 and 100-fold across all privacy budgets  $\epsilon$ .
7 Conclusions and future work
We give significant improvement in the running time for privately counting the number of embeddings of constant size subgraphs in a graph, without using noise based on global sensitivity. Despite a lot of work on private subgraph counting, efficient algorithms were not known for many subgraphs. Our results for triangles show significant benefits of our approach, by improving on the runtime over all prior private algorithms. Our approach of using approximations to sensitivity metrics opens the possibility of using other techniques from graph sampling and sketching to obtain more efficient algorithms. For general subgraphs, our focus here has been on theoretical bounds using multi-level local sensitivity combined with approximate queries. Developing efficient and practical algorithms for these problems is a good direction for future work.
This work was partially supported in part by the following grants: National Science Foundation Grants CCF-1918656 (Expeditions), OAC-1916805 (CINES), IIS-1955797, and CNS-2317193, VDH Grant PV-BII VDH COVID-19 Modeling Program VDH-21-501-0135, DTRA subcontract/ARA S-D00189-15-TO-01-UVA, NIH 2R01GM109718-07, CDC MIND cooperative agreement U01CK000589, and the U.S. DOE Exascale Computing Project's (ECP) (17-SC-20-SC) ExaGraph codesign center at Pacific Northwest National Laboratory.