Not all FPRASs are equal: demystifying FPRASs for DNF-counting

Abstract

The problem of counting the number of solutions of a DNF formula, also called #DNF, is a fundamental problem in artificial intelligence with applications in diverse domains ranging from network reliability to probabilistic databases. Owing to the intractability of the exact variant, efforts have focused on the design of approximate techniques for #DNF. Consequently, several Fully Polynomial Randomized Approximation Schemes (FPRASs) based on Monte Carlo techniques have been proposed. Recently, it was discovered that hashing-based techniques too lend themselves to FPRASs for #DNF. Despite significant improvements, the complexity of the hashing-based FPRAS is still worse than that of the best Monte Carlo FPRAS by polylog factors. Two questions were left unanswered in previous works: Can the complexity of the hashing-based techniques be improved? How do the various approaches stack up against each other empirically? In this paper, we first propose a new search procedure for the hashing-based FPRAS that removes the polylog factors from its time complexity. We then present the first empirical study of runtime behavior of different FPRASs for #DNF. The result of our study produces a nuanced picture. First of all, we observe that there is no single best algorithm that outperforms all others for all classes of formulas and input parameters. Second, we observe that the algorithm with one of the worst time complexities solves the largest number of benchmarks.

Appendix

For obtaining a concrete algorithm from the framework described in Algorithm 2, we need to instantiate the sub-procedures SampleHashFunction, GetLowerBound, GetUpperBound, EnumerateNextSol, ExtractSlice and ComputeIncrement for a particular counting problem. We now show how SymbolicDNFApproxMC [13], which uses Row Echelon XOR hash functions, and the concepts of Symbolic Hashing and Stochastic Cell-Counting, can be obtained through such instantiations. Then we prove that by substituting the BinarySearch procedure by ReverseSearch, the complexity of the resulting algorithm is improved by polylog factors.

1.1 SampleHashFunction

One can directly invoke the procedure SampleBase described in Algorithm 4 of [13] with minor modifications. This is shown in Algorithm 7. Note that the hash function A,b,y so obtained belongs to the Row Echelon XOR family.

1.2 Lower and upper bounds

As shown in [13], it suffices to search between ${\mathsf {n}} - {\mathsf {w}} - \log {\mathsf {hiThresh}}$ and ${\mathsf {n}} - {\mathsf {w}} + \log {\mathsf {m}} - \log {\mathsf {hiThresh}}$ hash constraints. Therefore the functions GetLowerBound and GetUpperBound return these values respectively.

1.3 Extracting a prefix slice

Procedure ExtractSlice required for ReverseSearch is shown in Algorithm 8. If flip is false, ExtractSlice returns the result of the procedure Extract (described in [13]) directly. Otherwise, the p-th bit of y^[y] is negated before being passed to Extract.

1.4 EnumerateNextSol

SymbolicDNFApproxMC enumerates solutions in the cell, in the order of a Gray code sequence, for better complexity. This is achieved by invoking the procedure enumREX (Algorithm 1 in [13]).

1.5 ComputeIncrement

Procedure CheckSAT (Algorithm 10 adapted from [13]) can be used to compute the increments to Y_cell as shown in Algorithm 9. The assignment s is divided into a solution x and a cube Fⁱ using the same Interpret function used in line 7 of Algorithm 6 in [13]. CheckSAT samples a cube at random in line 3 and checks if the assignment x satisfies it in line 5. The returned value follows the geometric distribution [9], and can be used to compute an accurate probabilistic estimate Y_cell of the true number of solutions in the cell [13].

Lemma 1

The complexity of BSAT is $\mathcal {O}({\mathsf {m}} \cdot {\mathsf {n}} \cdot {\mathsf {threshold}})$ .

Proof

Y_cell is incremented by c_x/m in line 5 of BSAT after a call to ComputeIncrement and CheckSAT. Since BSAT returns after Y_cell reaches threshold, the sum of c_x over all invocations of CheckSAT is m ⋅threshold. Every time c_x is incremented, the check in line 5 of CheckSAT is performed which takes $\mathcal {O}(n)$ time. Moreover, EnumerateNextSol also takes $\mathcal {O}(n)$ time as enumREX in [13] takes $\mathcal {O}(n)$ time. As a result, the complexity of BSAT is $\mathcal {O}({\mathsf {m}} \cdot {\mathsf {n}} \cdot {\mathsf {threshold}})$. $\ \Box$

Lemma 2

The complexity of ReverseSearch is $\mathcal {O}({\textsf {m}} \cdot {\textsf {n}} \cdot {\textsf {hiThresh}})$ .

Proof

In ReverseSearch, BSAT is invoked with different thresholds (say T₁,T₂,T₃…) in each iteration of the for loop in line 9 (Algorithm 6) depending on the value of Y_total. As a result of the check in line 13, it follows that T₁ + T₂ + T₃ + … = hiThresh. Therefore the complexity of all invocations of BSAT is $\mathcal {O}({\mathsf {m}}\cdot {\mathsf {n}}\cdot (T_{1} + T_{2} + T_{3} + \ldots )) = \mathcal {O}({\mathsf {m}}\cdot {\mathsf {n}}\cdot {\mathsf {hiThresh}})$. The complexity of ExtractSlice in line 12 is $\mathcal {O}({\mathsf {n}}(\log {\mathsf {m}} + \log (1/\varepsilon ^{2}))^{2})$ [13], and the loop in line 9 can be executed at most $\mathcal {O}(\log \log {\mathsf {m}})$ times. Therefore, the complexity of ReverseSearch is $\mathcal {O}(\log \log {\mathsf {m}}\cdot ({\mathsf {n}}(\log {\mathsf {m}} + \log (1/\varepsilon ^{2}))^{2}) + {\textsf {m}}\cdot {\textsf {n}} \cdot {\textsf {hiThresh}})$, which is $\mathcal {O}({\mathsf {m}}\cdot {\textsf {n}} \cdot {\textsf {hiThresh}})$. $\ \Box$

We are now ready to prove Theorem 1.

Proof

In Algorithm 2, ApproxMCCore is invoked $\mathcal {O}(\log (1/\delta ))$ times, which in turn makes a call to ReverseSearch. The complexity of SampleHashFunction is $\mathcal {O}({\mathsf {n}}(\log {\mathsf {m}} + \log (1/\varepsilon ^{2})))$ [13]. Since $\mathsf {hiThresh} = \mathcal {O}(1/\varepsilon ^{2})$, the complexity of Algorithm 2 is $\mathcal {O}(\mathsf {m}\cdot {\mathsf {n}}\cdot (1/\varepsilon ^{2})\cdot \log (1/\delta ) + \mathsf {n}(\log \mathsf {m} + \log (1/\varepsilon ^{2}))$, which is $\mathcal {O}({\mathsf {m}}\cdot {\mathsf {n}}\cdot (1/\varepsilon ^{2})\cdot \log (1/\delta ))$. $\ \Box$