Model Counting Meets F₀ Estimation

The complexity-theoretic study of model counting was initiated by Valiant who showed that this problem, in general, is #P-complete [66]. This motivated researchers to investigate approximate model counting and in particular achieving \((\varepsilon ,\delta)\) -approximation schemes. The complexity of approximate model counting depends on its representation. When the model \(\varphi\) is represented as a CNF formula \(\varphi\) , designing an efficient \((\varepsilon ,\delta)\) -approximation is NP-hard [62]. In contrast, when it is represented as a DNF formula, model counting admits an FPRAS (fully polynomial-time randomized approximation scheme) [43, 44]. We will use #CNF to refer to the case when \(\varphi\) is a CNF formula while #DNF to refer to the case when \(\varphi\) is a DNF formula.

For #CNF, Stockmeyer [62] provided a hashing-based randomized procedure that can compute ( \(\varepsilon ,\delta)\) -approximation within time polynomial in \(|\varphi |, \varepsilon ,\delta\) , given access to an NP oracle. Building on Stockmeyer’s approach and motivated by the unprecedented breakthroughs in the design of SAT solvers, researchers have proposed a series of algorithmic improvements that have allowed the hashing-based techniques for approximate model counting to scale to formulas involving hundreds of thousands of variables [2, 15, 16, 18, 26, 35, 39, 59, 60]. The practical implementations substitute NP oracle with SAT solvers. In the context of model counting, we are primarily interested in time complexity and therefore, the number of NP queries is of key importance. The emphasis on the number of NP calls also stems from practice as the practical implementation of model counting algorithms have shown to spend over 99% of their time in the underlying SAT calls [60].

Karp and Luby [43] proposed the first FPRAS scheme for #DNF, which was subsequently improved in the follow-up works [25, 44]. Chakraborty, Meel, and Vardi [16] demonstrated that the hashing-based framework can be extended to #DNF, hereby providing a unified framework for both #CNF and #DNF. Meel, Shrotri, and Vardi [49, 50, 51] subsequently improved the complexity of the hashing-based approach for #DNF and observed that hashing-based techniques achieve better scalability than that of Monte Carlo techniques.

Estimating \((\varepsilon ,\delta)\) -approximation of the \(k^{\rm th}\) frequency moments ( \(F_k\) ) is a central problem in the data streaming model [3]. In particular, considerable work has been done in designing algorithms for estimating the 0^th frequency moment ( \(F_0\) ), the number of distinct elements in the stream. While designing streaming algorithms, the primary resource concerns are two-fold: space complexity and processing time per element. For an algorithm to be considered efficient, these should be \({\rm poly}(\log N,1/\epsilon)\) where N is the size of the universe.¹

The first algorithm for computing \(F_0\) with a constant factor approximation was proposed by Flajolet and Martin, who assumed the existence of hash functions with ideal properties resulting in an algorithm with undesirable space complexity [32]. In their seminal work, Alon, Matias, and Szegedy designed an \(O(\log N)\) space algorithm for \(F_0\) with a constant approximation ratio that employs 2-universal hash functions [3]. Subsequent investigations into hashing-based schemes by Gibbons and Tirthapura [34] and Bar–Yossef, Kumar, and Sivakumar [8] provided \((\varepsilon , \delta)\) -approximation algorithms with space and time complexity \(\log N \cdot {\rm poly} ({1\over \varepsilon })\) . Subsequently, Bar-Yossef et al. proposed three algorithms with improved space and time complexity [7]. While the three algorithms employ hash functions, they differ conceptually in the usage of relevant random variables for the estimation of \(F_0\) . This line of work resulted in the development of an algorithm with optimal space complexity \({O}(\log N + {1\over \varepsilon ^2})\) and \(O(\log N)\) update time [42].

The above-mentioned works are in the setting where each data item \(a_i\) is an element of the universe. Subsequently, there has been a series of results of estimating \(F_0\) in rich scenarios with particular focus to handle the cases \(a_i \subseteq [N]\) such as a list or a multidimensional range [8, 53, 63, 65].

As mentioned above, the algorithmic developments for model counting and \(F_0\) estimation have largely relied on the usage of hashing-based techniques and yet these developments have, surprisingly, been separate, and rarely has a work from one community been cited by the other. In this context, we wonder whether it is possible to bridge this gap and if such an exercise would contribute to new algorithms for model counting as well as for \(F_0\) estimation? The main conceptual contribution of this work is an affirmative answer to the above question. First, we point out that the two well-known algorithms; Stockmeyer’s #CNF algorithm [62] that is further refined by Chakraborty et al. [16] and Gibbons and Tirthapura’s \(F_0\) estimation algorithm [34], are essentially the same.

The core idea of the hashing-based technique of Stockmeyer’s and Chakraborty et al’s scheme is to use pairwise independent hash functions to partition the solution space (satisfying assignments of a CNF formula) into roughly equal and small cells, wherein a cell is small if the number of solutions is less than a pre-computed threshold, denoted by \(\mathsf {Thresh}\) . Then a good estimate for the number of solutions is the number of solutions in an arbitrary cell \(\times\) number of cells. To partition the solution space, pairwise independent hash functions are used. To determine the appropriate number of cells, the solution space is iteratively partitioned as follows. At the \(m^{th}\) iteration, a hash function with range \(\lbrace 0,1\rbrace ^m\) is considered resulting in cells \(h^{-1}(y)\) for each \(y\in \lbrace 0,1\rbrace ^m\) . An NP oracle can be employed to check whether a particular cell (for example \(h^{-1}(0^m)\) ) is small by enumerating solutions one by one until we have either obtained \(\mathsf {Thresh}\) +1 number of solutions or we have exhaustively enumerated all the solutions. If the cell \(h^{-1}(0^m)\) is small, then the algorithm outputs \(t\times 2^m\) as an estimate where t is the number of solutions in the cell \(h^{-1}(0^m)\) . If the cell \(h^{-1}(0^m)\) is not small, then the algorithm moves on to the next iteration where a hash function with range \(\lbrace 0,1\rbrace ^{m+1}\) is considered.

We now describe Gibbons and Tirthapura’s algorithm for \(F_0\) estimation which we call the \(\mathsf {Bucketing}\) algorithm. We will assume the universe \([N] = \lbrace 0,1\rbrace ^n\) . The algorithm maintains a bucket of size \(\mathsf {Thresh}\) and starts by picking a hash function \(h:\lbrace 0,1\rbrace ^n \rightarrow \lbrace 0,1\rbrace ^n\) . It iterates over sampling levels. At level m, when a data item x comes, if \(h(x)\) starts with \(0^m\) , then x is added to the bucket. If the bucket overflows, then the sampling level is increased to \(m+1\) and all elements x in the bucket other than the ones with \(h(x)=0^{m+1}\) are deleted. At the end of the stream, the value \(t\times 2^{m}\) is output as the estimate where t is the number of elements in the bucket and m is the sampling level.

These two algorithms are conceptually the same. In the \(\mathsf {Bucketing}\) algorithm, at the sampling level m, it looks at only the first m bits of the hashed value; this is equivalent to considering a hash function with range \(\lbrace 0,1\rbrace ^m\) . Thus the bucket is nothing but all the elements in the stream that belong to the cell \(h^{-1}(0^m)\) . The final estimate is the number of elements in the bucket times the number of cells, identical to Chakraborty et. al’s algorithm. In both algorithms, to obtain an \((\varepsilon , \delta)\) approximation, the \(\mathsf {Thresh}\) value is chosen as \(O({1 \over \varepsilon ^2})\) and the median of \(O(\log {1\over \delta })\) independent estimations is output.

Motivated by the conceptual identity between the two algorithms, we further explore the connections between algorithms for model counting and \(F_0\) estimation.

We present notations and preliminaries in Section 2. We then present the transformation of \(F_0\) estimation to model counting in Section 3. In Section 4, we provide a recipe to transform \(L_0\) sampling algorithms into constrained sampling algorithms. We then focus on distributed #DNF in Section 5. In Section 6, we present the transformation of model counting algorithms to structured set streaming algorithms. We conclude in Section 7 with a discussion of future research directions.

We would like to emphasize that the primary objective of this work is to provide a unifying framework for \(F_0\) estimation and model counting. Therefore, when designing new algorithms based on the transformation recipes, we intentionally focus on conceptually cleaner algorithms and leave potential improvements in time and space complexity for future work.

A data stream \(\mathbf {a}\) over domain \([N]\) can be represented as \(\mathbf {a} = a_1, a_2, \ldots a_m\) wherein each item \(a_i \in [N]\) . Let \(\mathbf {a}_u = \cup _{i} \lbrace a_i\rbrace\) . \(F_0\) of the stream \(\mathbf {a}\) is \(|\mathbf {a}_u|\) . We are often interested in a probably approximately correct scheme that returns an \((\varepsilon ,\delta)\) -estimate c, i.e.,

Let \(\lbrace x_1, x_2, \ldots , x_n\rbrace\) be a set of Boolean variables. For a Boolean formula \(\varphi\) , let \(\mathsf {Vars}(\varphi)\) denote the set of variables appearing in \(\varphi\) . Throughout the article, unless otherwise stated, we will assume that the relationship \(n = |\mathsf {Vars}(\varphi)|\) holds. We denote the set of all satisfying assignments of \(\varphi\) by \(\mathsf {Sol}(\varphi)\) .

The propositional model counting problem is to compute \(|\mathsf {Sol}(\varphi)|\) for a given formula \(\varphi\) . A probably approximately correct (or PAC) counter is a probabilistic algorithm \({\mathsf {ApproxCount}}(\cdot , \cdot ,\cdot)\) that takes as inputs a formula \(\varphi\) , a tolerance \(\varepsilon \gt 0\) , and a confidence \(\delta \in (0, 1]\) , and returns a \((\varepsilon ,\delta)\) -estimate c, i.e.,

PAC guarantees are also sometimes referred to as \((\varepsilon ,\delta)\) -guarantees. We use #CNF (respectively, #DNF) to refer to the model counting problem when \(\varphi\) is represented as CNF (respectively, DNF).

Given a formula \(\varphi\) , tolerance parameter \(\varepsilon \gt 0\) , confidence parameter \(\delta \gt 0\) , a constrained sampler \(\mathsf {UnifSampler}\) returns \(\sigma \in \mathsf {Sol}(\varphi)\) such thatAnd the algorithm \(\mathsf {UnifSampler}\) succeeds with probability \(1-\delta\) .

Let \(n,m\in \mathbb {N}\) and \(\mathcal {H}(n,m) \triangleq \lbrace h:\lbrace 0,1\rbrace ^{n} \rightarrow \lbrace 0,1\rbrace ^m \rbrace\) be a family of hash functions mapping \(\lbrace 0,1\rbrace ^n\) to \(\lbrace 0,1\rbrace ^m\) . We use \(h \xleftarrow {R} \mathcal {H}(n,m)\) to denote the probability space obtained by choosing a function h uniformly at random from \(\mathcal {H}(n,m)\) .

We will use \(\mathcal {H}_{\mathsf {k-wise}}(n,m)\) to refer to a \(k-\) wise independent family of hash functions mapping \(\lbrace 0,1\rbrace ^n\) to \(\lbrace 0,1\rbrace ^m\) .

In this work, one hash family of particular interest is \(\mathcal {H}_{\mathsf {Toeplitz}}(n,m)\) , which is known to be 2-wise independent [12]. The family is defined as follows: \(\mathcal {H}_{\mathsf {Toeplitz}}(n,m) \triangleq \lbrace h: \lbrace 0,1\rbrace ^n \rightarrow \lbrace 0,1\rbrace ^m \rbrace\) is the family of functions of the form \(h(x) = Ax+b\) with A is a Toeplitz matrix in \(\mathbb {F}_{2}^{m \times n}\) and \(b \in \mathbb {F}_{2}^{m \times 1}\) . A matrix is Toeplitz if for every diagonal (top-left to bottom-right) its entries are the same. Another related hash family of interest is \(\mathcal {H}_{\mathsf {xor}}(n,m)\) wherein \(h(X)\) is again of the form \(Ax+b\) where \(A \in \mathbb {F}_{2}^{m \times n}\) and \(b \in \mathbb {F}_{2}^{m \times 1}\) . Both \(\mathcal {H}_{\mathsf {Toeplitz}}\) and \(\mathcal {H}_{\mathsf {xor}}\) are 2-wise independent but it is worth noticing that \(\mathcal {H}_{\mathsf {Toeplitz}}\) can be represented with \(\Theta (n)\) -bits while \(\mathcal {H}_{\mathsf {xor}}\) requires \(\Theta (mn)\) bits of representation. We use both these families, as we use results from prior works that use both these hash families.

For every \(\ell \in \lbrace 1, \ldots , n\rbrace\) , the \(\ell ^{th}\) prefix-slice of h, denoted \(h_{\ell }\) , is a map from \(\lbrace 0,1\rbrace ^{n}\) to \(\lbrace 0,1\rbrace ^\ell\) , where \(h_{\ell }(y)\) is the first \(\ell\) bits of \(h(y)\) . Observe that when \(h(x) = Ax+b\) , \(h_{\ell }(x) = A_{\ell }x+b_{\ell }\) , where \(A_{\ell }\) denotes the submatrix formed by the first \(\ell\) rows of A and \(b_{\ell }\) is the first \(\ell\) entries of the vector b.

As shown in Algorithm 2, the hash functions depend on the strategy being implemented. The subroutine \(\mathsf {PickHashFunctions}(\mathcal {H}, t)\) returns a collection of t independent hash functions from the family \(\mathcal {H}\) . We use H to denote the collection of hash functions returned, this collection is viewed as either 1-dimensional array or as a 2-dimensional array. When H is 1-dimensional array, \(H[i]\) denotes the ith hash function of the collection and when H is a 2-dimensional array \(H[i][j]\) is the \([i, j]\) th hash functions.

For each of the three algorithms, their corresponding sketches can be viewed as arrays of the size of \(35\log (1/\delta)\) . The parameter \(\mathsf {Thresh}\) is set to \(96/\varepsilon ^2\) .

For a new item x, the update of \(\mathcal {S}\) , as shown in Algorithm 3 is as follows:

Finally, for each of the algorithms, we estimate \(F_0\) based on the sketch \(\mathcal {S}\) as described in the subroutine \(\mathsf {ComputeEst}\) presented as Algorithm 4. It is crucial to note that the estimation of \(F_0\) is performed solely using the sketch \(\mathcal {S}\) for the Bucketing and Minimum algorithms. The Estimation algorithm requires an additional parameter r that depends on a loose estimate of \(F_0\) ; we defer details to Section 3.4.

Observe that for each of the algorithms, the final computation of \(F_0\) estimation depends on the sketch \(\mathcal {S}\) . Therefore, as long as for two streams \(\mathbf {a}\) and \(\hat{\mathbf {a}}\) , if their corresponding sketches say \(\mathcal {S}\) and \(\hat{\mathcal {S}}\) , respectively, are equivalent, the three schemes presented above would return the same estimates. The recipe for a transformation of streaming algorithms to model counting algorithms is based on the following insight:

In the rest of this section, we will apply the above recipe to the three types of \(F_0\) estimation algorithms and derive corresponding model counting algorithms. In particular, we show how applying the above recipe to the \(\mathsf {Bucketing}\) algorithm leads us to reproduce the state-of-the-art hashing-based model counting algorithm, \(\mathsf {ApproxMC}\) , proposed by Chakraborty et al. [16]. Applying the above recipe to \(\mathsf {Minimum}\) and \(\mathsf {Estimation}\) allows us to obtain fundamentally different schemes. In particular, we observe while model counting algorithms based on \(\mathsf {Bucketing}\) and \(\mathsf {Minimum}\) provide FPRAS’s when \(\varphi\) is DNF, such is not the case for the algorithm derived based on \(\mathsf {Estimation}\) .

The \(\mathsf {Bucketing}\) algorithm chooses a set H of pairwise independent hash functions and maintains a sketch \(\mathcal {S}\) that we will describe. Here we use \(\mathcal {H}_{\mathsf {Toeplitz}}\) as our choice of pairwise independent hash functions. The sketch \(\mathcal {S}\) is an array where, each \(\mathcal {S}[i]\) is of the form \(\langle c_i, m_i\rangle\) . We say that the relation \(\mathcal {P}_1 (\mathcal {S}, H, \mathbf {a}_u)\) holds if

The following lemma due to Bar–Yossef et al. [7] and Gibbons and Tirthapura [34] captures the relationship among the sketch \(\mathcal {S}\) , the relation \(\mathcal {P}_1\) and the number of distinct elements of a multiset.

To design an algorithm for model counting, based on the bucketing strategy, we turn to the subroutine introduced by Chakraborty, Meel, and Vardi: \(\mathsf {BoundedSAT}\) , whose properties are formalized as follows:

Equipped with Proposition 1, we now turn to designing an algorithm for model counting based on the Bucketing strategy. The algorithm follows in a similar fashion to its streaming counterpart where \(m_i\) is iteratively incremented until the number of solutions of the formula ( \(\varphi \wedge H[i]_{m_i}(x) = 0^{m_i})\) is less than \(\mathsf {Thresh}\) . Interestingly, an approximate model counting algorithm, called \(\mathsf {ApproxMC}\) , based on bucketing strategy was discovered independently by Chakraborty et al. [15] in 2013. We reproduce an adaptation \(\mathsf {ApproxMC}\) in Algorithm 5 to showcase how \(\mathsf {ApproxMC}\) can be viewed as a transformation of the \(\mathsf {Bucketing}\) algorithm. In the spirit of \(\mathsf {Bucketing}\) , \(\mathsf {ApproxMC}\) seeks to construct a sketch \(\mathcal {S}\) of size \(t \in \mathcal {O}(\log (1/\delta))\) . To this end, for every iteration of the loop, we continue to increment the value of the loop until the conditions specified by the relation \(\mathcal {P}_1 (\mathcal {S}, H, \mathsf {Sol}(\varphi))\) are met. For every iteration i, the estimate of the model count is \(c_i \times 2^{m_i}\) . Finally, the estimate of the model count is simply the median of the estimation of all the iterations. Since in the context of model counting, we are concerned with time complexity, wherein both \(\mathcal {H}_{\mathsf {Toeplitz}}\) and \(\mathcal {H}_{\mathsf {xor}}\) lead to the same time complexity. Furthermore, Chakraborty et al. [14] observed no difference in empirical runtime behavior due to \(\mathcal {H}_{\mathsf {Toeplitz}}\) and \(\mathcal {H}_{\mathsf {xor}}\) .

The following theorem establishes the correctness of \(\mathsf {ApproxMC}\) , and the proof follows from Lemma 1 and Proposition 1.

For a given multiset \(\mathbf {a}\) (eg: a data stream or solutions to a model), we now specify the property \(\mathcal {P}_2(\mathcal {S}, H, \mathbf {a}_{u})\) . The sketch \(\mathcal {S}\) is an array of sets indexed by members of H that holds lexicographically p minimum elements of \(H[i](\mathbf {a}_u)\) where p is \(\min (\frac{96}{\varepsilon ^2}, |\mathbf {a}_{u}|)\) . \(\mathcal {P}_2\) is the property that specifies this relationship. More formally, the relationship \(\mathcal {P}_2\) holds, if the following conditions are met.

Here, \(\preceq\) is the natural lexicographic order among the strings. The following lemma due to Bar-Yossef et al. [7] establishe the relationship between the property \(\mathcal {P}_2\) and the number of distinct elements of a multiset. Let \(\max (S_i)\) denote the largest element of the set \(S_i\) .

Therefore, we can transform the \(\mathsf {Minimum}\) algorithm for \(F_0\) estimation to that of model counting given access to a subroutine that can compute \(\mathcal {S}\) such that \(\mathcal {P}_2(\mathcal {S}, H, \mathsf {Sol}(\varphi))\) holds true. The following proposition establishes the existence and complexity of such a subroutine, called \(\mathsf {FindMin}\) :

Equipped with Proposition 2, we are now ready to present the algorithm for model counting, which we call \(\mathsf {ApproxModelCountMin}\) . Since the complexity of \(\mathsf {FindMin}\) is PTIME when \(\varphi\) is in DNF, we have \(\mathsf {ApproxModelCountMin}\) as an FPRAS for DNF formulas.

We now adapt the \(\mathsf {Estimation}\) algorithm to model counting. For a given stream \(\mathbf {a}\) and chosen hash functions H, the sketch \(\mathcal {S}\) corresponding to the estimation-based algorithm satisfies the following relation \(\mathcal {P}_3(\mathcal {S}, H, \mathbf {a}_u)\) :where the procedure \(\mathsf {TrailZero}(z)\) is the length of the longest all-zero suffix of z. Bar–Yossef et al. [7] show the following relationship between the property \(\mathcal {P}_3\) and \(F_0\) .

Following the recipe outlined above, we can transform an \(F_0\) streaming algorithm to a model counting algorithm by designing a subroutine that can compute the sketch for the set of all solutions described by \(\varphi\) and a subroutine to find r. The following proposition achieves the first objective for CNF formulas using a small number of calls to an NP oracle:

We note that unlike Propositions 1 and 2, we do not know whether \(\mathsf {FindMaxRange}\) can be implemented efficiently when \(\varphi\) is a DNF formula. For a degree-s polynomial \(h: \mathbb {F}_{2^n} \rightarrow \mathbb {F}_{2^n}\) , we can efficiently test whether h has a root by computing \(\mathsf {gcd}(h(x), x^{2^n}-x)\) , but it is not clear how to simultaneously constrain some variables according to a DNF term.

Equipped with Proposition 3, we obtain \(\mathsf {ApproxModelCountEst}\) that takes in a formula \(\varphi\) and a suitable value of r and returns \(|\mathsf {Sol}(\varphi)|\) . The key idea of \(\mathsf {ApproxModelCountEst}\) is to repeatedly invoke \(\mathsf {FindMaxRange}\) for each of the chosen hash functions and compute the estimate based on the sketch \(\mathcal {S}\) and the value of r. The following theorem summarizes the time complexity and guarantees of \(\mathsf {ApproxModelCountEst}\) for CNF formulas.

In order to obtain r, we run in parallel another counting algorithm based on the simple \(F_0\) -estimation algorithm [3, 32] which we call \(\mathsf {FlajoletMartin}\) . Given a stream \(\mathbf {a}\) , the \(\mathsf {FlajoletMartin}\) algorithm chooses a random pairwise-independent hash function \(h \in H_{xor}(n,n)\) , computes the largest r so that for some \(x \in \mathbf {a}_u\) , the r least significant bits of \(h(x)\) are zero, and outputs r. Alon, Matias and Szegedy [3] showed that \(2^r\) is a 5-factor approximation of \(F_0\) with probability \(3/5\) . Using our recipe, we can convert \(\mathsf {FlajoletMartin}\) into an algorithm that approximates the number of solutions to a CNF formula \(\varphi\) within a factor of 5 with probability 3/5. It is easy to check that using the same idea as in Proposition 3, this algorithm requires \(O(\log n)\) calls to an NP oracle.

In the design of streaming algorithms reducing the space complexity is of primary concern whereas in model counting algorithms the goal is to minimize the run time or the number of NP queries made. Having established a recipe to transform sketch-based streaming algorithms into model counting algorithms, a natural question that arises is the relationship between the space complexity of the streaming algorithm and the number of NP queries made by the model counting algorithm. In this section, we attempt to clarify this relationship. In the following, we will fold the hash function h also in the sketch S. With this simplification, instead of writing \(P(S,h,\mathsf {Sol}(\varphi))\) we write \(P(S,\mathsf {Sol}(\varphi))\) .

We first introduce some complexity-theoretic notation. For a complexity class \(\mathcal {C}\) , a language L belongs to the complexity class \(\exists \cdot \mathcal {C}\) if there is a polynomial \(q(\cdot)\) and a language \(L^{\prime } \in \mathcal {C}\) such that for every x

Consider a streaming algorithm for \(F_0\) that constructs a sketch such that \(P(S, a_u)\) holds for some property P using which we can estimate \(|a_u|\) , where the size of S is poly-logarithmic in the size of the universe and polynomial in \(1/\varepsilon\) . Now consider the following Sketch-Language

The above theorem gives a general upper bound on the complexity of the model counting algorithm based on the complexity of the language \(L_{sketch}\) . In the specific instances that we illustrate (bucketing, minimum, and estimation), the sketch language is in \({\rm coNP}\) . This will lead to a \({\rm FP}^{\Sigma _2^{\mathrm{P}}}\) algorithm for model counting. For example, consider the minimum-based algorithm. The sketch language is the following:

The above language is in the class \({\rm coNP}\) : If \(\langle \varphi , \langle h, v_1, \ldots , v_t\rangle \rangle\) does not belong to the sketch language, then there is a satisfying assignment a of \(\varphi\) such that there exists i, \(0 \le i \le t-1\) and \(v_i \lt h(a) \lt v_{i+1}\) (where \(v_0\) is the empty string). Thus an NP machine for the complement language works by guessing an assignment a and verifying that a satisfies \(\varphi\) and \(h(a)\) lies between \(v_i\) and \(v_{i+1}\) for some i, \(0 \le i \le t-1\) . Thus the sketch language is in coNP. Since \(\exists \cdot {\rm coNP}\) is same as the class \(\Sigma ^{\mathrm{P}}_2\) , we obtain a \({\rm FP}^{\Sigma _2^{\mathrm{P}}}\) algorithm. Since \(t = O(1/\varepsilon ^2)\) and h maps from n-bit strings to 3n-bit strings, it follows that the size of the sketch is \(O(n/\varepsilon ^2)\) . Thus the number of queries made by the algorithm is \(O(n/\varepsilon ^2)\) .

Note that in all three model counting algorithms that were obtained, are probabilistic polynomial-time algorithms that make queries to languages in NP. The above generic transformation gives a deterministic polynomial-time algorithm that makes queries to a \(\Sigma _2^{\mathrm{P}}\) oracle. Precisely characterizing the properties of the sketch that lead to probabilistic algorithms making only NP queries is an interesting direction to explore.

As noted in Section 3.2, the algorithms based on Bucketing were already known and have witnessed a detailed technical development from both applied and algorithmic perspectives. The model counting algorithms based on Minimum and Estimation are new. We discuss some potential implications of these new algorithms to SAT solvers and other aspects.

MaxSAT solvers with native support for XOR constraints. When the input formula \(\varphi\) is represented as CNF, then \(\mathsf {ApproxMC}\) , the model counting algorithm based on Bucketing strategy, invokes NP oracle over CNF-XOR formulas, i.e., formulas expressed as a conjunction of CNF and XOR constraints. The XOR constraints appear due to the need to evaluate the hash functions which are evaluations of XORs. The significant improvement in the runtime performance of \(\mathsf {ApproxMC}\) owes to the design of SAT solvers with native support for CNF-XOR formulas [59, 60, 61]. Such solvers have now found applications in other domains such as cryptoanalysis. It is perhaps worth emphasizing that the proposal of \(\mathsf {ApproxMC}\) was crucial to renewed interest in the design of SAT solvers with native support for CNF-XOR formulas. As observed in Section 3.3, the algorithm based on the Minimum strategy would ideally invoke a MaxSAT solver that can handle XOR constraints naively. We believe that the Minimum-based algorithm will ignite interest in the design of MaxSAT solver with native support for XOR constraints.

FPRAS for DNF based on Estimation. In Section 3.4, we were unable to show that the model counting algorithm obtained based on Estimation is FPRAS when \(\varphi\) is represented as DNF. The algorithms based on Estimation have been shown to achieve optimal space efficiency in the context of \(F_0\) estimation. In this context, an open problem is to investigate whether the Estimation-based strategy lends itself to FPRAS for DNF counting.

Empirical Study of FPRAS for DNF Based on Minimum. Meel et al. [50, 51] observed that FPRAS for DNF based on Bucketing has superior performance, in terms of the number of instances solved, to that of FPRAS schemes based on the Monte Carlo framework. In this context, a natural direction of future work would be to conduct an empirical study to understand the behavior of FPRAS scheme based on the Minimum strategy.

Our recipe for the transformation of \(L_0\) sampling algorithms captured by the unified framework of Algorithm 8 to constrained sampling is based on two simple insights:

As an example, let us consider Algorithm 8 and we can formalize the property \(\mathcal {P}_{4}(\mathcal {S}[i],h, \mathbf {a}_u)\) as follows:

We apply the above recipe to translate the unified algorithm presented in Algorithm 8 to one for constrained sampling. To this end, we rely on the following generalization of \(\mathsf {BoundedSAT}\) that can simulate exact sparse recovery.

Equipped with \(\mathsf {GenBoundedSAT}\) , we present the algorithm \(\mathsf {UnifSampler}\) in Algorithm 9 that takes in a formula \(\varphi\) , tolerance parameter \(\varepsilon\) , and confidence parameter \(\delta\) , and returns a sample \(\sigma \in \mathsf {Sol}(\varphi)\) . Since \(\mathsf {GenBoundedSAT}\) implements exact sparse recovery, the algorithm \(\mathsf {UnifSampler}\) enjoys theoretical guarantees for the quality of its samples.

The communication cost for the Bucketing and Estimation-based algorithms is nearly optimal in their dependence on k and \(\varepsilon\) . Woodruff and Zhang [67] showed that the randomized communication complexity of estimating \(F_0\) up to a \(1+\varepsilon\) factor in the distributed functional monitoring setting is \(\Omega (k/\varepsilon ^2)\) . We can reduce \(F_0\) estimation problem to distributed DNF counting. Namely, if for the \(F_0\) estimation problem, the j’th site receives items \(a_1, \ldots , a_m \in [N]\) , then for the distributed DNF counting problem, \(\varphi _j\) is a DNF formula on \(\lceil \log _2 N \rceil\) variables whose solutions are exactly \(a_1, \ldots , a_m\) in their binary encoding. Thus, we immediately get an \(\Omega (k/\varepsilon ^2)\) lower bound for the distributed DNF counting problem. Finding the optimal dependence on N for \(k\gt 1\) remains an interesting open question.³

A particular representation we are interested in is where each set is presented as the set of satisfying assignments to a DNF formula. Let \(\varphi\) be a DNF formula over n variables. Then the DNF Set corresponding to \(\varphi\) is the set of satisfying assignments of \(\varphi\) . The size of this representation is the number of terms in the formula \(\varphi\) .

A stream over DNF sets is a stream of DNF formulas \(\varphi _1, \varphi _2, \ldots\) . Given such a DNF stream, the goal is to estimate \(|\bigcup _{i} S_i|\) where \(S_i\) the DNF set represented by \(\varphi _i\) . This quantity is same as the number of satisfying assignments of the formula \(\vee _i \varphi _i\) . We show that the algorithms described in the previous section carry over to obtain \((\epsilon , \delta)\) estimation algorithms for this problem with space and per-item time \(\mathrm{poly}(1/\epsilon , n, k, \log (1/\delta))\) where k is the size of the formula.

Notice that this model generalizes the traditional streaming model where each item of the stream is an element \(x\in U\) as it can be represented as single term DNF formula \(\phi _x\) whose only satisfying assignment is x. This model also generalizes certain other models considered in the streaming literature that we discuss later.

Instead of using Minimum-value based algorithm, we could adapt Bucketing-based algorithm to obtain an algorithm with similar space and time complexities. As noted earlier, some of the set streaming models considered in the literature can be reduced the DNF set streaming. We discuss them next.

A d dimensional range over an universe \(U = \lbrace 0, \ldots , 2^n-1\rbrace\) is defined as \([a_1,b_1] \times [a_2,b_2] \times \cdots \times [a_d, b_d]\) . Such a range represents the set of tuples \((x_1,\ldots ,x_d)\) where \(a_i \le x_i \le b_i\) and \(x_i\) is an integer. Note that every d-dimensional range can be succinctly represented by the tuple \(\langle a_1, b_1, \ldots , a_d, b_d\rangle\) . A multi-dimensional stream is a stream where each item is a d-dimensional range. The goal is to compute \(F_0\) of the union of the d-dimensional ranges efficiently. We will show that \(F_0\) computation over multi-dimensional ranges can be reduced to \(F_0\) computation over DNF sets. Using this reduction we arrive at a simple algorithm to compute \(F_0\) over multi-dimensional ranges.

Using the above reduction and Theorem 7, we obtain an algorithm for estimating \(F_0\) over multidimensional ranges in a range-efficient manner.

Representing Multidimensional Ranges as CNF Formulas. Since the algorithm, \(\mathsf {APS\mbox{-}Estimator}\) , presented in [64], employs a sampling-based technique, a natural question is whether there exists a hashing-based technique that achieves per-item time polynomial in n and d. We note that the above approach of representing a multi-dimensional range as DNF formula does not yield such an algorithm. This is because there exist d-dimensional ranges whose DNF representation requires \(\Omega (n^d)\) size.

This leads to the question of whether we can obtain a super-polynomial lower bound on the time per item. We observe that such a lower bound would imply \(\mathrm{P} \ne \mathrm{NP}\) . For this, we note the following.

This is because a single dimensional range \([a, b]\) can also be represented as a CNF formula of size \(O(n)\) [13] and thus the CNF formula for R is a conjunction of formulas along each dimension. Thus the problem of computing \(F_0\) over d-dimensional ranges reduces to computing \(F_0\) over a stream where each item of the stream is a CNF formula. As in the proof of Theorem 7, we can adapt Minimum-value based algorithm for CNF streams. When a CNF formula \(\varphi _i\) arrive, we need to compute the t lexicographically smallest elements of \(h(\mathsf {Sol}(\varphi _i))\) where \(h \in \mathcal {H}_{\mathsf {Toeplitz}}(n,3n)\) . By Proposition 2, this can be done in polynomial-time by making \(O(tnd)\) calls to an NP oracle since \(\varphi _i\) is a CNF formula over nd variables. Thus if P equals NP, then the time taken per range is polynomial in n, d, and \(1/\varepsilon ^2\) . Thus a super polynomial time lower bound on time per item implies that P differs from NP.

Another example of a structured stream is where each item of the stream is an affine space represented by \(Ax = B\) where A is a boolean matrix and B is a zero-one vector. Without loss of generality, we may assume that A is a \(n \times n\) matrix. Thus an affine stream consists of \(\langle A_1, B\rangle , \langle A_2, B_2\rangle \ldots\) , where each \(\langle A_i, B_i\rangle\) is succinctly represents a set \(\lbrace x \in \lbrace 0,1 \rbrace ^n\mid A_ix= B_i\rbrace\) .

For a \(n \times n\) Boolean matrix A and a zero-one vector B, let \(\mathsf {Sol}(\langle A, B\rangle)\) denote the set of all x that satisfy \(Ax = B\) .