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 #PComplete [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 databasequery optimization [21] and SATsolving [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 dynamicprogramming 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 SATsolving [25]. Compact representations are therefore promising to improve dynamicprogrammingbased algorithms for model counting [2, 27].In particular, we consider the use of Algebraic Decision Diagrams (ADDs) [3] for model counting in a dynamicprogramming framework. An ADD is a compact representation of a realvalued 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 dynamicprogramming 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 realvalued 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 dynamicprogramming framework for weighted model counting that utilizes ADDs as a compact data structure. In particular:

We lift the BDDbased approach of [25] for Boolean satisfiability to an ADDbased 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 dynamicprogramming 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 stateoftheart 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 socalled literalweight 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 literalweight 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 literalweighted model count is #PComplete [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 literalweighted 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 polynomialtime count on the SDD [23]. Nevertheless, these usuallycompact 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 nonterminal 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 nonterminal 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 floatingpoint 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 literalweighted 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 realvalued function, which reduces the number of Boolean variables by “summing out” a single variable. Variable projection in realvalued 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 databasequery 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 literalweight 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 literalweight 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 literalweight 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 literalweighted model counting of CNF formulas using ADDs through dynamicprogramming techniques.
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 literalweight function. Assume that returns an injection , and moreover that for every call to and the following properties hold:

,

, and

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 MaximumCardinality 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 initiallyempty 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 onebyone, inorder, 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 leftdeep 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 stateoftheart 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 secondlargest CNF model counting benchmark family.^{1}^{1}1From http://www.cril.univartois.fr/KC/benchmarks.html
Our source code and experimental data can be obtained from a repository.^{2}^{2}2See 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 E52650v2 CPU (2.60GHz) with 32 GB of memory. The time cap for each job is 100second.
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 
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 stateoftheart exact model counters: , ^{3}^{3}3 does not natively support weighted model counting. In order to compare on the weighted benchmarks, we use to compile CNF into dDNNF then use to compute the weighted model counts., , , and ^{4}^{4}4 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 E52650v2 CPU (2.60GHz) with 32 GB of memory. The time cap for each job is 1000second.
Note that computes long double floatingpoint counts for weighted model counting, whereas other model counters use double precision. For unweighted model counting, uses 64bit floats, while other model counters use arbitraryprecision integers. We count benchmarks on which the floatingpoint 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 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 floatingpoint 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.
Regarding correctness, to compare model counts produced by different counters, we consider nonnegative 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 dynamicprogramming 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 stateoftheart 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 ADDbased 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 wellstudied theoretically, with close connections to treewidth and treedecompositions [11, 8]. On the other hand, Bouquet’s Method is much less wellknown. 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 arbitraryprecision 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 dynamicprogramming techniques for model counting using other compact representations, , affine ADDs [30].
Acknowledgment
This work was supported in part by NSF grant IIS1527668, by the BigData PrivateCloud Research Cyberinfrastructure MRIaward funded by NSF under grant CNS1338099, 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 3SAT 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(23), 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, AixMarseille 1 (1999)
 [6] Bryant, R.E.: Graphbased 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(12), 41–85 (1999)
 [12] van Dijk, T., van de Pol, J.: Sylvan: multicore 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 realvalued decision diagrams. In: AAAI. pp. 1049–1055 (2014)
 [15] Hoey, J., StAubin, 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.: Conjunctivequery 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 decisionDNNF 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.: Constraintbased random stimuli generation for hardware verification. AI Magazine 28(3), 13–13 (2007)
 [23] Oztok, U., Darwiche, A.: A topdown 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(13), 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 belieffunction propagation. In: Classic Works of the DempsterShafer 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 lineartime 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 DavisPutnam 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)
Comments
There are no comments yet.