ADDMC: Exact Weighted Model Counting with Algebraic Decision Diagrams

07/11/2019
by   Jeffrey M. Dudek, et al.
Rice University
4

We compute exact literal-weighted model counts of CNF formulas. Our algorithm employs dynamic programming, with Algebraic Decision Diagrams as the primary data structure. This technique is implemented in ADDMC, a new model counter. We empirically evaluate various heuristics that can be used with ADDMC. We also compare ADDMC to state-of-the-art exact model counters (Cachet, c2d, d4, miniC2D, and sharpSAT) on the two largest CNF model counting benchmark families (BayesNet and Planning). ADDMC solves the most benchmarks in total within the given timeout.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 1

page 2

page 3

page 4

08/20/2020

DPMC: Weighted Model Counting by Dynamic Programming on Project-Join Trees

We propose a unifying dynamic-programming framework to compute exact lit...
03/15/2012

Dynamic programming in in uence diagrams with decision circuits

Decision circuits perform efficient evaluation of influence diagrams, bu...
06/28/2020

Parallel Weighted Model Counting with Tensor Networks

A promising new algebraic approach to weighted model counting makes use ...
01/16/2014

Probabilistic Relational Planning with First Order Decision Diagrams

Dynamic programming algorithms have been successfully applied to proposi...
05/18/2018

Approximate Model Counting by Partial Knowledge Compilation

Model counting is the problem of computing the number of satisfying assi...
10/18/2016

Weighted Positive Binary Decision Diagrams for Exact Probabilistic Inference

Recent work on weighted model counting has been very successfully applie...
10/18/2021

Arjun: An Efficient Independent Support Computation Technique and its Applications to Counting and Sampling

Given a Boolean formula φ over the set of variables X and a projection s...
This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction

Model counting

is a fundamental problem in artificial intelligence, with applications in machine learning, probabilistic reasoning, and verification

[13, 4, 22]. Given an input set of constraints, with the focus in this paper on Boolean constraints, the model counting problem is to count the number of satisfying assignments. Although this problem is #P-Complete [36], a variety of tools exist that can handle industrial sets of constraints, cf. [28, 23].

Dynamic programming is a powerful technique that has been applied both across computer science [16] and specifically to model counting [2, 27]. The key idea is to solve a large problem by solving a sequence of smaller subproblems and then incrementally combining these solutions into the final result. Dynamic programming provides a natural framework to solve a variety of problems defined on sets of constraints: subproblems can be formed by partitioning the constraints into sets, called clusters. This framework has also been instantiated into algorithms for database-query optimization [21] and SAT-solving [35, 1, 25]. Techniques for local computation can also be seen as a variant of this framework, e.g. in theorem proving [37] or probabilistic inference [31].

In this work, we study two algorithms that follow this dynamic-programming framework and can be adapted for model counting: bucket elimination [11] and Bouquet’s Method [5]. Bucket elimination aims to minimize the amount of information needed to be carried between subproblems. When this information must be stored in an uncompressed table, bucket elimination will, with some carefully chosen sequence of clusters, require the minimum possible amount of intermediate data (as governed by the treewidth of the input formula [2]

). Intermediate data, however, need not necessarily be stored uncompressed. Several works have shown that using compact representations of intermediate data can dramatically improve bucket elimination for Bayesian inference

[26, 30, 8]. Moreover, it has been observed that using compact representations – in particular, Binary Decision Diagrams (BDDs) – can allow Bouquet’s Method to outperform bucket elimination for SAT-solving [25]. Compact representations are therefore promising to improve dynamic-programming-based algorithms for model counting [2, 27].

In particular, we consider the use of Algebraic Decision Diagrams (ADDs) [3] for model counting in a dynamic-programming framework. An ADD is a compact representation of a real-valued function as a directed acyclic graph. ADDs have been used in stochastic model checking [19] and stochastic planning [15]. ADDs have also been used for model counting [14], but not within a dynamic-programming framework. For functions with logical structure, an ADD representation can be exponentially smaller than the explicit representation. The construction of an ADD depends heavily on the choice of an order on the variables that form its domain, called a diagram variable order. Some variable orders may produce ADDs that are exponentially smaller than others for the same real-valued function. A variety of techniques exist in prior work to heuristically find diagram variable orders [33, 18].

In addition to the diagram variable order, both bucket elimination and Bouquet’s Method require another order on the variables to build and arrange the clusters of input constraints; we call this a cluster variable order. We show in Section 5.1 that the choice of heuristics to find cluster variable orders has a significant impact on the runtime performance of both bucket elimination and Bouquet’s Method.

The primary contribution of this work is a dynamic-programming framework for weighted model counting that utilizes ADDs as a compact data structure. In particular:

  • We lift the BDD-based approach of [25] for Boolean satisfiability to an ADD-based approach for weighted model counting.

  • We implement this algorithm using ADDs and a variety of existing heuristics to produce , a new weighted model counter.

  • We perform an experimental comparison of with a variety of other model counters and show that solves the most benchmarks within the given timeout.

In Section 3, we outline the theoretical foundation for performing weighted model counting with ADDs. In Section 4, we present an algorithm for performing weighted model counting through dynamic-programming techniques, and discuss a variety of existing heuristics that can be used in the algorithm. In Section 5.1, we compare the performance of various heuristics in and demonstrate that Bouquet’s Method is competitive with bucket elimination. In Section 5.2, we compare against state-of-the-art model counters on two benchmark families: probabilistic inference () and planning (). In particular, is able to solve 87% of benchmarks while the next best solver solves 84%. is the fastest solver on 44% of the benchmarks. Through further analysis, we observe that is less competitive on the benchmarks but is a dramatic improvement over other counters on the benchmarks. Finally, we conclude in Section 6.

2 Preliminaries

In this section, we introduce weighted model counting, the central problem of this work, and Algebraic Decision Diagrams, the primary data structure we use to solve weighted model counting.

2.1 Weighted Model Counting

The central problem of this work is to compute the weighted model count of a Boolean function, which we now define.

Let be a Boolean function over a set of variables , and let be an arbitrary function. The weighted model count of is

The function is called a weight function. In this work, we focus on so-called literal-weight functions, where the weight of a model can be expressed as the product of weights associated with all satisfied literals. That is, where the weight function can be expressed for all as

for some functions . One can interpret these literal-weight functions as assigning a real number weight to each literal: to and to . It is common to restrict attention to weight functions whose range lies in the positive reals or in .

When is given as a CNF formula, computing the literal-weighted model count is #P-Complete [36]. Several algorithms and tools for weighted model counting directly reason about the CNF representation. For example, uses DPLL search combined with component caching and clause learning to perform weighted model counting [28].

If is given in a compact representation – , as a Binary Decision Diagram (BDD) [6] or as a Sentential Decision Diagram (SDD) [10] – computing the literal-weighted model count can be done in time polynomial in the size of the representation. One recent tool for weighted model counting that exploits this is , which compiles the input CNF formula into an SDD and then performs a polynomial-time count on the SDD [23]. Nevertheless, these usually-compact representations may be exponential in the size of the corresponding CNF formula in the worst case.

2.2 Algebraic Decision Diagrams

The central data structure we use in this work is an Algebraic Decision Diagram (or ADD) [3], a compact representation of a function as a directed acyclic graph. Formally, an ADD is a tuple , where is a set of Boolean variables, is an arbitrary set (called the carrier set), is an injection (called the diagram variable order), and is a rooted directed acyclic graph satisfying the following three properties. First, every terminal node of is labeled with an element of . Second, every non-terminal node of is labeled with an element of and has two outgoing edges labeled 0 and 1. Finally, for every path in , the labels of the visited non-terminal nodes must occur in increasing order under . ADDs were originally designed for use in matrix multiplication and shortest path algorithms [3] and have since been used for stochastic model checking [19] and stochastic planning [15]. In this work, we do not need arbitrary carrier sets; it is sufficient to consider ADDs with .

An ADD is a compact representation of a function . Although there are many ADDs representing each such function , for each injection there is a unique minimal ADD that represents with as the diagram variable order, called the canonical ADD. ADDs can be minimized in polynomial time, so it is typical to only work with canonical ADDs. Given two ADDs representing functions and , the ADDs representing and can also be computed in polynomial time.

The choice of diagram variable order can have a dramatic impact on the size of the ADD. A variety of techniques exist to heuristically find diagram variable orders. Moreover, since Binary Decision Diagrams (or BDDs) [6] can be seen as ADDs with carrier set , there is significant overlap with the techniques to find variable orders for BDDs. We discuss these heuristics in more detail in Section 4.

Several tools exist for efficiently manipulating ADDs. Here we use the tool CUDD [32], which supports carrier sets

and (using floating-point arithmetic)

. In particular, CUDD offers APIs for carrying out multiplication and addition of ADDs.

3 Using ADDs for Weighted Model Counting with Early Projection

An ADD with carrier set can be used to represent both a Boolean function and a weight function . ADDs are thus a natural candidate as a data structure for weighted model counting algorithms.

In this section, we outline theoretical foundations for performing weighted model counting with ADDs. We consider first the general case of weighted model counting. We then specialize to literal-weighted model counting of CNF formulas and show how the technique of early projection can take advantage of such factored representations for and .

3.1 General Weighted Model Counting

We assume that the Boolean formula and weight function are represented as ADDs. The goal is to compute , the weighted model count of w.r.t. . To do this, we define two operations on functions that can be efficiently computed using the ADD representation: product and projection. These operations are combined in Theorem 3.1 to perform weighted model counting.

First, we define the product of two functions. Let and be sets of variables. The product of and is the function defined for all by

Note that the operator is commutative, associative, and has an identity element (that maps to ). If and are Boolean formulas, their product is the Boolean function corresponding to their conjunction . As mentioned earlier, CUDD enables implementation of the operator for ADDs.

Second, we define the projection

of a real-valued function, which reduces the number of Boolean variables by “summing out” a single variable. Variable projection in real-valued functions is similar to variable elimination in Bayesian networks

[38].

Let be a set of variables and let . The projection of w.r.t. is the function defined for all by

One can check that projection is commutative, i.e., for all variables and functions . CUDD enables implementation of the projection operator for ADDs via ADD addition.

We are now ready to use product and projection to perform weighted model counting, through the following theorem. Let be a Boolean function over a set of variables , and let be an arbitrary weight function. Then

Theorem 3.1 suggests that can be computed by constructing an ADD for and another for , computing the ADD for their product , and performing a sequence of projections to obtain the final weighted model count. Unfortunately, we see in Section 5 that this “monolithic” approach is infeasible on many benchmarks: the ADD representation for is often too large, even with the best possible diagram variable order.

Instead, we show in the following section a technique for avoiding the construction of an ADD for by rearranging the products and projections.

3.2 Early Projection

A key technique in symbolic computation is that of early projection: when performing a product followed by a projection (as in Theorem 3.1), it is sometimes possible and advantageous to perform the projection first. Early projection is possible when one component of the product does not depend on the projected variable. Early projection has been used in a variety of settings, including database-query optimization [17], symbolic model checking [7], and satisfiability solving [24]. The formal statement is as follows.

[Early Projection] Let and be sets of variables, , and . For all ,

The use of early projection in Theorem 3.1 is quite limited when and have already been represented as ADDs; since on many benchmarks, both and depend on most of the variables. If is a CNF formula and is a literal-weight function, however, both and can be rewritten as the product of smaller functions. This can significantly increase the applicability of early projection.

Assume that is a CNF formula, i.e., given as a set of clauses. For every clause , observe that is a Boolean function (where is the set of variables that appear in ) that maps satisfying assignments to 1 and unsatisfying assignments to 0. One can check using Definition 3.1 that .

Similarly, assume that is a literal-weight function. For every , define to be the function that maps to and to . One can check using Definition 3.1 that .

When is a CNF formula and is a literal-weight function, then, we can rewrite Theorem  3.1 as

(1)

By taking advantage of the commutative and associative properties of the product operator and the commutative property of projection, it is possible to rearrange Equation (1) in order to apply early projection. We present an algorithm to perform this rearrangement in the following section.

4 Dynamic Programming for Model Counting

We now discuss an algorithm for performing literal-weighted model counting of CNF formulas using ADDs through dynamic-programming techniques.

Input: : nonempty CNF formula over variables
Input: : literal-weight function
Output: : weighted model count of
1
2
3
4 for  do
5      
         /* constructing cluster of rank */
6      
         /* the variables in will be projected at step in the next loop */
7      
8 end for
9
  /* collecting variables declared in which do not appear in */
10 for  do
11       if  then
12            
13             for  do
14                  
15             end for
16            if  then
17                  
18                  
19             end if
20            
21       end if
22      
23 end for
return
Algorithm 1 ADD Weighted Model Counting

Our algorithm is presented as Algorithm 1. Broadly, our algorithm partitions the clauses of a formula into a sequence of clusters . For each cluster, we construct the ADD corresponding to the conjunction of its clauses. These ADDs are then incrementally combined via the product operator. Throughout, each variable of the ADD is projected as early as Theorem 3.2 allows (where indicates the variables that can be projected after each iteration ). At the end of the algorithm, all variables have been projected and the resulting ADD has a single node representing the weighted model count. This algorithm can be seen as rearranging the terms of Equation 1 (according to the clusters) in order to perform the projections indicated by at each step .

The helper function constructs the ADD representing the product of all clauses in cluster (including, possibly, ADDs that were added to on line 1 of prior iterations) using as the diagram variable order. The remaining functions that appear within Algorithm 1, namely , , , and , represent heuristics that can be used to tune the specifics of Algorithm 1.

Before discussing the various heuristics, we assert the correctness of Algorithm 1 in the following theorem. Let be a nonempty CNF formula over variables and let be a literal-weight function. Assume that returns an injection , and moreover that for every call to and the following properties hold:

  1. ,

  2. , and

  3. for all s.t. , the sets of variables and are disjoint.

Then Algorithm 1 returns .

Condition 1 ensures that is a partition of the clauses of . Condition 2 ensures that line 1 always places in a cluster that has not yet been processed. Condition 3 ensures that every variable projected in every step does not appear in later clusters (i.e., for all ). These three invariants are sufficient to prove that Algorithm 1 indeed computes the weighted model count of w.r.t. . All the heuristics we describe in this section satisfy the conditions of Theorem 1.

In the remainder of this section, we discuss various existing heuristics that can be used to implement , , , and , We compare the performance of these heuristics for Algorithm 1 in Section 5.

4.1 Heuristics for and

The heuristic chosen for indicates the diagram variable order to use in every ADD constructed by Algorithm 1. The heuristic chosen for indicates the variable order which, when combined with the heuristic for , is used to order the clauses of (BE orders clauses by the smallest variable that appears, while BM orders them by the largest variable that appears). In this work, we consider seven possible heuristics for each variable order: Random, MCS, LexP, LexM, InvMCS, InvLexP, and InvLexM.

A simple heuristic for these variable orders is to randomly order the variables, i.e., for a formula over variables , sample an injection uniformly at random. We call this the Random heuristic. Random is a baseline for comparison of the other variable order heuristics.

For the remaining heuristics, we must define the Gaifman graph of a formula . The Gaifman graph of has a vertex for every variable in . Two vertices are connected by an edge if and only if the corresponding variables appear in the same clause of .

One such heuristic is called Maximum-Cardinality Search [33]. At each step of the heuristic, the next variable chosen is the variable adjacent in to the greatest number of previously chosen variables (breaking ties arbitrarily). We call this the MCS heuristic for variable order.

Another such heuristic is called Lexicographic search for perfect orders [18]. Each vertex of is assigned a set of vertices (called the label), which is initially empty. At each step of the heuristic, the next variable chosen is the variable whose label is lexicographically smallest among the unchosen variables (breaking ties arbitrarily). Then is added to the label of its neighbors in . We call this the LexP heuristic for variable order.

A similar heuristic is called Lexicographic search for minimal orders [18]. As before, each vertex of is assigned an initially-empty label. At each step of the heuristic, the next variable chosen is again the variable whose label is lexicographically smallest (breaking ties arbitrarily). In this case, is added to the label of every variable where there is a path in s.t. every is unchosen and the label of is lexicographically smaller than the label of . We call this the LexM heuristic for variable order.

Additionally, the variable orders produced by each of the heuristics MCS, LexP, and LexM can be inverted. We call these new heuristics InvMCS, InvLexP, and InvLexM.

4.2 Heuristics for

The heuristic chosen for indicates the strategy for clustering the clauses of . In this work, we consider three possible heuristics to be chosen for that satisfy the conditions of Theorem 1: Mono, BE, and BM.

One simple case is when is constant on all clauses, , when for all . In this case, all clauses of are placed in , so line 1 of Algorithm 1 combines every clause of into a single ADD before performing projections. This corresponds to the monolithic approach we discussed in Section 3.1. We thus call this the Mono heuristic for . Notice that the performance of Algorithm 1 with Mono does not depend on the heuristic for or . This heuristic has previously been applied to ADDs in the context of knowledge compilation [14].

A more complex heuristic assigns the rank of each clause to be the smallest -rank of the variables that appear in the clause. That is, . This heuristic corresponds to bucket elimination [11], so we call this the BE heuristic. In this case, notice that every clause containing can only appear in with . It follows that has always been projected by the end of iteration of Algorithm 1 using BE.

A closely related heuristic assigns the rank of each clause to be the largest -rank of the variables that appear in the clause. That is, . This heuristic corresponds to Bouquet’s Method [5], so we call this the BM heuristic. We can make no similar guarantees about when each variable is projected in Algorithm 1 using BM.

4.3 Heuristics for

The heuristic chosen for indicates the strategy for combining the ADDs produced from each cluster. In this work, we consider two possible heuristics to use for that satisfy the conditions of Theorem 1: List and Tree.

One heuristic is when selects to place in the closest cluster that satisfies the conditions of Theorem 1, namely the next cluster to be processed. That is, . Under this heuristic, Algorithm 1 equivalently builds an ADD for each cluster and then combines the list of ADDs one-by-one, in-order, projecting variables as early as possible. At every iteration, there is a single intermediate ADD representing the combination of previous clusters. We call this the List heuristic.

Another heuristic is when selects to place in the furthest cluster that satisfies the conditions of Theorem 1. That is, returns the smallest such that and are not disjoint (or returns , if . At every iteration, there may be many intermediate ADDs representing the combination of previous clusters. We call this the Tree heuristic.

Notice that the computational structure of Algorithm 1 can be represented by a tree of clusters, where the cluster is the child of whenever the ADD produced from cluster is placed in after line 1 (i.e., at iteration ). These trees are always left-deep under the List heuristic, but can be more complex using the Tree heuristic.

A clustering heuristic is a valid combination of a heuristic and a heuristic. The five clustering heuristics are: , , , , and .

5 Empirical Evaluation

We aim to: (1) find good heuristic configurations for our tool , and (2) compare against state-of-the-art exact model counters [28], [9], [20], [23], and [34]. We use the largest CNF model counting benchmark family , which contains weighted benchmarks [29]. Although our focus is on weighted model counting, we also consider unweighted benchmarks, which constitute the second-largest CNF model counting benchmark family.111From http://www.cril.univ-artois.fr/KC/benchmarks.html

Our source code and experimental data can be obtained from a repository.222See https://github.com/vardigroup/ADDMC

5.1 Experiment 1: Comparing Heuristics

heuristic configurations are constructed from five options for clustering heuristics (, -, -, -, and -) and seven options for variable order heuristics (, , , , , , and ). Using one variable order heuristic for the cluster variable order and another for the diagram variable order gives us configurations in total. We compare these configurations to find the best combination of heuristics.

We run each job on an exclusive node in a homogeneous Linux cluster. Each node has a Xeon E5-2650v2 CPU (2.60-GHz) with 32 GB of memory. The time cap for each job is 100-second.

5.1.1 Result

Table 1 reports the best, median, and worst across all heuristic configurations. Evidently, some configurations perform quite well while others perform quite poorly. We choose - with cluster variable order and diagram variable order as the representative configuration for Experiment 2.

Clustering Cluster var Diagram var Benchmarks solved Ranking
Total
- 1060 326 1386 Best (overall)
- 1022 348 1370 Best -
- 1036 331 1367 Best -
- 1000 265 1265 Best -
- 394 214 608 Median
85 154 239 Best
- 15 60 75 Worst
Table 1: A comparison of the number of benchmarks solved by the best, median, and worst heuristic configurations after 100 seconds. The best configuration for each clustering heuristic is also shown. has possible heuristic configurations, and their performance varies widely on both benchmark families.
Figure 1: A cactus plot of the number of benchmarks solved by the best, median, and worst heuristic configurations for a given timeout. ’s configurations have significantly different performance.

Figure 1 shows the best, median, and worst heuristic configurations. The wide range of performance indicates that the choice of heuristics is essential to the competitiveness of .

5.2 Experiment 2: Comparing Exact Model Counters

In the previous experiment, the best heuristic configuration is - clustering with cluster variable order and diagram variable order. We now compare using this configuration against state-of-the-art exact model counters: , 333 does not natively support weighted model counting. In order to compare on the weighted benchmarks, we use to compile CNF into d-DNNF then use to compute the weighted model counts., , , and 444 does not natively support weighted model counting. We are not aware of a straightforward method to have compute the weighted model counts of the benchmarks.. Again, we use two standard CNF model counting benchmark families: (weighted) and (unweighted).

We run each job on an exclusive node in a homogeneous Linux cluster. Each node has a Xeon E5-2650v2 CPU (2.60-GHz) with 32 GB of memory. The time cap for each job is 1000-second.

Note that computes long double floating-point counts for weighted model counting, whereas other model counters use double precision. For unweighted model counting, uses 64-bit floats, while other model counters use arbitrary-precision integers. We count benchmarks on which the floating-point numbers used by overflow as failures.

5.2.1 Result

Model counter Benchmarks solved
Total
Number Percentage Number Percentage Number Percentage
1077 98.72% 353 63.38% 1430 86.77%
938 85.98% 444 79.71% 1382 83.86%
916 83.96% 426 76.48% 1342 81.43%
839 76.90% 441 79.17% 1280 77.67%
776 71.13% 410 73.61% 1186 71.97%
- - 428 76.84% - -
Table 2: A comparison of with a variety of existing model counters on 1648 weighted and unweighted benchmarks, sorted by the number of total benchmarks completed within 1000 seconds (since is an unweighted model counter, we did not evaluate it on the weighted benchmarks). solves the most benchmarks overall. is less competitive on the benchmarks but is a dramatic improvement on the benchmarks.

Table 2 summarizes the performance of six exact model counters. solves the most benchmarks overall. Split by benchmark family, solves fewer benchmarks than the other methods on the benchmarks. One partial explanation is that the floating-point numbers used by overflow on 35 of these benchmarks, which we count as failures. On the other hand, is a dramatic improvement over other tools on the benchmarks. In particular, is able to solve 114 benchmarks that no other tool we tested can. See Figure 2 and Figure 3 for a more detailed analysis of solver runtime on the and benchmarks respectively.

Figure 2: A cactus plot of the number of unweighted benchmarks solved by various tools for a given timeout. is outperformed by the state of the art on these benchmarks.
Figure 3: A cactus plot of the number of weighted benchmarks solved by various tools for a given timeout. significantly outperforms the state of the art on these benchmarks.

Regarding correctness, to compare model counts produced by different counters, we consider non-negative real numbers equal when:

(2)

The first case is mostly for weighted model counts, which are at most 1. The second case is for unweighted model counts, which can be large integers.

Within the equality tolerance in Equation (2), produces the same model counts as other tools (), with two exceptions. First, on the benchmarks, outputs some numbers that are different from other tools. A similar issue occurs with on the benchmarks.

6 Discussion

We developed a dynamic-programming framework for weighted model counting that captures both bucket elimination and Bouquet’s Method. We implemented this algorithm in ADDMC, a new exact weighted model counter. We used ADDMC to compare bucket elimination and Bouquet’s Method across a variety of variable order heuristics on two standard model counting benchmark families and concluded that Bouquet’s Method is competitive with bucket elimination. Moreover, we demonstrated that ADDMC solved more benchmarks than state-of-the-art model counters () on the combined benchmark set of and . On further analysis, is outperformed by the other tools on the benchmarks but is the fastest tool on the benchmarks. Thus is valuable as part of a portfolio solver, and ADD-based approaches to model counting in general are promising and deserve further study. For example, it would be interesting to discover the fundamental reason why our approach works well on the benchmarks but not on the benchmarks.

Bucket elimination has been well-studied theoretically, with close connections to treewidth and tree-decompositions [11, 8]. On the other hand, Bouquet’s Method is much less well-known. Previous work [25] has also observed that Bouquet’s Method can outperform bucket elimination using compact representations. An interesting direction for future work is to develop a theoretical framework to explain the relative performance between bucket elimination and Bouquet’s Method.

In this work, we focused on ADDs implemented in the library CUDD. There are other ADD libraries that may be fruitful to explore in the future. For example, the ADD library Sylvan [12] supports arbitrary-precision arithmetic and multicore operations on ADDs, which would allow us to compute large unweighted model counts (and thus improve the performance on the benchmarks) and investigate the impact of parallelism on our techniques. It would also be interesting to explore dynamic-programming techniques for model counting using other compact representations, , affine ADDs [30].

Acknowledgment

This work was supported in part by NSF grant IIS-1527668, by the Big-Data Private-Cloud Research Cyberinfrastructure MRI-award funded by NSF under grant CNS-1338099, by the Ken Kennedy Institute Computer Science & Engineering Enhancement Fellowship funded by the Rice Oil & Gas HPC Conference, by the Ken Kennedy Institute for Information Technology 2017/18 Cray Graduate Fellowship, and by Rice University.

References

  • [1] Aguirre, A.S.M., Vardi, M.Y.: Random 3-SAT and BDDs: the plot thickens further. In: Intl. Conf. on Principles and Practice of Constraint Programming. pp. 121–136 (2001)
  • [2] Bacchus, F., Dalmao, S., Pitassi, T.: Solving #SAT and Bayesian inference with backtracking search. J. of AI Research 34, 391–442 (2009)
  • [3] Bahar, R.I., Frohm, E.A., Gaona, C.M., Hachtel, G.D., Macii, E., Pardo, A., Somenzi, F.: Algebraic decision diagrams and their applications. Formal Methods in System Design 10(2-3), 171–206 (1997)
  • [4] Biere, A., Heule, M., van Maaren, H.: Handbook of satisfiability, vol. 185. IOS Press (2009)
  • [5] Bouquet, F.: Gestion de la dynamicité et énumération d’impliquants premiers: une approche fondée sur les diagrammes de décision binaire. Ph.D. thesis, Aix-Marseille 1 (1999)
  • [6] Bryant, R.E.: Graph-based algorithms for Boolean function manipulation. IEEE Trans. on Computers 35(8) (1986)
  • [7] Burch, J., Clarke, E., Long, D.: Symbolic model checking with partitioned transition relations. In: VLSI. pp. 49–58 (1991)
  • [8] Chavira, M., Darwiche, A.: Compiling Bayesian networks using variable elimination. In: IJCAI. pp. 2443–2449 (2007)
  • [9] Darwiche, A.: New advances in compiling CNF into decomposable negation normal form. In: ECAI. pp. 328–332 (2004)
  • [10] Darwiche, A.: SDD: a new canonical representation of propositional knowledge bases. In: IJCAI. pp. 819–826 (2011)
  • [11] Dechter, R.: Bucket elimination: a unifying framework for reasoning. AI 113(1-2), 41–85 (1999)
  • [12] van Dijk, T., van de Pol, J.: Sylvan: multi-core decision diagrams. In: International Conference on Tools and Algorithms for the Construction and Analysis of Systems. pp. 677–691. Springer (2015)
  • [13] Domshlak, C., Hoffmann, J.: Probabilistic planning via heuristic forward search and weighted model counting. J. of AI Research 30, 565–620 (2007)
  • [14] Fargier, H., Marquis, P., Niveau, A., Schmidt, N.: A knowledge compilation map for ordered real-valued decision diagrams. In: AAAI. pp. 1049–1055 (2014)
  • [15] Hoey, J., St-Aubin, R., Hu, A., Boutilier, C.: SPUDD: stochastic planning using decision diagrams. In: Conf. on Uncertainty in AI. pp. 279–288 (1999)
  • [16] Howard, R.A.: Dynamic programming. Management Science (1966)
  • [17] Kolaitis, P., Vardi, M.: Conjunctive-query containment and constraint satisfaction. J. of Computer and System Sciences 61(2), 302–332 (2000)
  • [18] Koster, A.M., Bodlaender, H.L., Van Hoesel, S.P.: Treewidth: computational experiments. Electronic Notes in Discrete Mathematics 8, 54–57 (2001)
  • [19] Kwiatkowska, M., Norman, G., Parker, D.: Stochastic model checking. In: Intl. School on Formal Methods for the Design of Computer, Communication and Software Systems. pp. 220–270 (2007)
  • [20] Lagniez, J.M., Marquis, P.: An improved decision-DNNF compiler. In: IJCAI. pp. 667–673 (2017)
  • [21] McMahan, B.J., Pan, G., Porter, P., Vardi, M.Y.: Projection pushing revisited. In: Intl. Conf. on Extending Database Technology. pp. 441–458 (2004)
  • [22] Naveh, Y., Rimon, M., Jaeger, I., Katz, Y., Vinov, M., Marcu, E., Shurek, G.: Constraint-based random stimuli generation for hardware verification. AI Magazine 28(3), 13–13 (2007)
  • [23] Oztok, U., Darwiche, A.: A top-down compiler for sentential decision diagrams. In: IJCAI. pp. 3141–3148 (2015)
  • [24]

    Pan, G., Vardi, M.: Symbolic techniques in satisfiability solving. J. of Automated Reasoning

    35(1-3), 25–50 (2005)
  • [25] Pan, G., Vardi, M.Y.: Search vs. symbolic techniques in satisfiability solving. In: Intl. Conf. on Theory and Applications of Satisfiability Testing. pp. 235–250 (2004)
  • [26] Poole, D., Zhang, N.L.: Exploiting contextual independence in probabilistic inference. J. of AI Research 18, 263–313 (2003)
  • [27] Samer, M., Szeider, S.: Algorithms for propositional model counting. J. of Discrete Algorithms 8(1), 50–64 (2010)
  • [28] Sang, T., Bacchus, F., Beame, P., Kautz, H.A., Pitassi, T.: Combining component caching and clause learning for effective model counting. SAT pp. 20–28 (2004)
  • [29] Sang, T., Beame, P., Kautz, H.A.: Performing Bayesian inference by weighted model counting. In: AAAI. vol. 5, pp. 475–481 (2005)
  • [30] Sanner, S., McAllester, D.: Affine algebraic decision diagrams and their application to structured probabilistic inference. In: IJCAI. pp. 1384–1390 (2005)
  • [31]

    Shenoy, P.P., Shafer, G.: Axioms for probability and belief-function propagation. In: Classic Works of the Dempster-Shafer Theory of Belief Functions, pp. 499–528. Springer (2008)

  • [32] Somenzi, F.: CUDD: CU decision diagram package - release 2.4.0. University of Colorado at Boulder (2009)
  • [33] Tarjan, R.E., Yannakakis, M.: Simple linear-time algorithms to test chordality of graphs, test acyclicity of hypergraphs, and selectively reduce acyclic hypergraphs. SIAM J. on Computing 13(3), 566–579 (1984)
  • [34] Thurley, M.: sharpsat–counting models with advanced component caching and implicit bcp. In: International Conference on Theory and Applications of Satisfiability Testing. pp. 424–429. Springer (2006)
  • [35] Uribe, T.E., Stickel, M.E.: Ordered binary decision diagrams and the Davis-Putnam procedure. In: Intl. Conf. on Constraints in Computational Logics. pp. 34–49 (1994)
  • [36] Valiant, L.G.: The complexity of enumeration and reliability problems. SIAM J. on Computing 8(3), 410–421 (1979)
  • [37] Wilson, N., Mengin, J.: Logical deduction using the local computation framework. In: ECSQARU. pp. 386–396 (1999)
  • [38] Zhang, N.L., Poole, D.: A simple approach to Bayesian network computations. In: Canadian Conf. on AI. pp. 171–178 (1994)