ADDMC: Weighted Model Counting with Algebraic Decision Diagrams

TL;DR

This paper introduces ADDMC, an exact weighted model counting algorithm using Algebraic Decision Diagrams, which outperforms existing counters on a large benchmark set.

Contribution

The paper presents a novel model counting algorithm employing Algebraic Decision Diagrams and demonstrates its superior performance over state-of-the-art methods.

Findings

ADDMC significantly outperforms existing model counters on benchmark tests.

Empirical evaluation shows the effectiveness of heuristics used with ADDMC.

ADDMC improves the virtual best solver performance in weighted model counting.

Abstract

We present an algorithm to compute exact literal-weighted model counts of Boolean formulas in Conjunctive Normal Form. Our algorithm employs dynamic programming and uses Algebraic Decision Diagrams as the primary data structure. We implement this technique in ADDMC, a new model counter. We empirically evaluate various heuristics that can be used with ADDMC. We then compare ADDMC to state-of-the-art exact weighted model counters (Cachet, c2d, d4, and miniC2D) on 1914 standard model counting benchmarks and show that ADDMC significantly improves the virtual best solver.

Figures

Tables

Table 1. Table 1: The numbers of benchmarks solved (of 1914) in 10 seconds by the best, second-best, median, and worst ADDMC heuristic configurations.

Clustering	Clus. var.	Diag. var.	Solved	Name
BM-Tree	LexP	MCS	1202	Best1
BE-Tree	InvLexP	MCS	1200	Best2
BE-List	LexP	LexP	504	Median
BE-List	Random	Random	53	Worst

Table 2. Table 2: The numbers of benchmarks solved (of 1914) in 1000 seconds — uniquely (i.e., benchmarks solved by no other solver), fastest, and in total — by five weighted model counters and two virtual best solvers ( VBS1 and VBS0 ).

Solvers	Benchmarks solved
	Unique	Fastest	Total
VBS1 (with ADDMC)	–	–	1771
VBS0 (without ADDMC)	–	–	1647
d4	12	283	1587
c2d	0	13	1417
miniC2D	8	61	1407
ADDMC	124	763	1404
Cachet	14	651	1383

Equations

$$W(\phi )=\sum _{\tau \in 2^X}\phi (\tau )\cdot W(\tau ).$$

$$W(\tau )=\prod _{x\in \tau }{W}^{+}(x)\cdot \prod _{x\in X\setminus \tau }{W}^{-}(x)$$

$$(A\cdot B)(\tau )=A(\tau \cap X)\cdot B(\tau \cap Y).$$

$$({\exists }_{x}A)(\tau )=A(\tau )+A(\tau \cup \left\{x\right\}).$$

$${\exists }_{X}A={\exists }_{x_1}{\exists }_{x_2}\dots {\exists }_{x_n}A.$$

$$W(\phi )=({\exists }_X(\phi \cdot W))(\varnothing ).$$

$${\exists }_x(A\cdot B)=\left({\exists }_{x}A\right)\cdot B.$$

$${\exists }_{X^{\prime }}(A\cdot B)=\left({\exists }_{X^{\prime }}A\right)\cdot B.$$

$$W(\phi )=\left({\exists }_X\left(\prod _{\gamma \in \phi }\gamma \cdot \prod _{x\in X}{W}_x\right)\right)(\varnothing ).$$

$$\sum _{\tau \in 2^X}A(\tau )$$

$$=\sum _{\tau \in 2^{X\setminus \left\{x_n\right\}}}(({\exists }_{x_n}A)(\tau ))$$

$$\sum _{\tau \in 2^X}A(\tau )$$

$$=\sum _{\tau \in 2^{X\setminus \left\{x_{n-1},x_n\right\}}}({\exists }_{x_{n-1}}{\exists }_{x_n}A)(\tau )$$

$$⋮$$

$$=\sum _{\tau \in 2^{\varnothing }}({\exists }_{x_1}\dots {\exists }_{x_{n-1}}{\exists }_{x_n}A)(\tau )$$

$$=({\exists }_{x_1}\dots {\exists }_{x_{n-1}}{\exists }_{x_n}A)(\varnothing )$$

$$=({\exists }_{X}A)(\varnothing )$$

$$\sum _{\tau \in 2^X}(\phi \cdot W)(\tau )$$

$$({\exists }_X(\phi \cdot W))(\varnothing )$$

$$=\sum _{\tau \in 2^X}\phi (\tau )\cdot W(\tau )$$

$$=W(\phi )$$

$$({\exists }_x$$

$$=(A\cdot B)(\tau )+(A\cdot B)(\tau \cup \left\{x\right\})$$

$$=A(\tau \cap X)\cdot B(\tau \cap Y)+A((\tau \cup \left\{x\right\})\cap X)\cdot B((\tau \cup \left\{x\right\})\cap Y)$$

$$=A(\tau \cap X)\cdot B(\tau \cap Y)+A((\tau \cup \left\{x\right\})\cap X)\cdot B(\tau \cap Y)$$

$$=A(\tau \cap X)\cdot B(\tau \cap Y)+A(\tau \cap X\cup \left\{x\right\})\cdot B(\tau \cap Y)$$

$$=(A(\tau \cap X)+A(\tau \cap X\cup \left\{x\right\}))\cdot B(\tau \cap Y)$$

$$=({\exists }_{x}A)(\tau \cap X)\cdot B(\tau \cap Y)$$

$$=({\exists }_{x}A)(\tau \cap (X\setminus \left\{x\right\}))\cdot B(\tau \cap Y)$$

$$=(({\exists }_{x}A)\cdot B)(\tau )$$

$$W(\phi )=\left({\exists }_{Y_i}\left(\prod _{\begin{array}{c}j\ge i\\ B\in {\kappa }_j\end{array}}B\cdot \prod _{x\in Y_i}{W}_x\right)\right)(\varnothing ).$$

$${\exists }_{Y_{i+1}}\left(\prod _{\begin{array}{c}j\ge i+1\\ B\in {\kappa }_j^{\prime }\end{array}}B\cdot \prod _{x\in Y_{i+1}}{W}_x\right)$$

$$=$$

$${\exists }_{Y_{i+1}}\left(\left({\exists }_{X_i}\prod _{D\in {\kappa }_i}D\cdot \prod _{x\in X_i}{W}_x\right)\cdot \prod _{\begin{array}{c}j\ge i+1\\ B\in {\kappa }_j\end{array}}B\cdot \prod _{x\in Y_{i+1}}{W}_x\right).$$

$${\exists }_{Y_{i+1}}\left(\prod _{\begin{array}{c}j\ge i+1\\ B\in {\kappa }_j^{\prime }\end{array}}B\cdot \prod _{x\in Y_{i+1}}{W}_x\right)$$

$$=$$

$$W(\phi )=\left({\exists }_{X_m}\left(\prod _{B\in {\kappa }_m}B\cdot \prod _{x\in Y_m}{W}_x\right)\right)(\varnothing ).$$

$$A_m={\exists }_{X_m}\left(\prod _{B\in {\kappa }_m}B\cdot \prod _{x\in Y_m}{W}_x\right),$$

Full text

1 Introduction

Model counting is a fundamental problem in artificial intelligence, with applications in machine learning, probabilistic reasoning, and verification (?; ?; ?). 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 (?), a variety of tools exist that can handle industrial sets of constraints, cf. (?; ?).

Dynamic programming is a powerful technique that has been applied across computer science (?), including to model counting (?; ?). 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 (?) and SAT-solving (?; ?; ?). Techniques for local computation can also be seen as a variant of this framework, e.g., in theorem proving (?) or probabilistic inference (?).

In this work, we study two algorithms that follow this dynamic-programming framework and can be adapted for model counting: bucket elimination (?) and Bouquet’s Method (?). 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 (?). Intermediate data, however, need not be stored uncompressed. Several works have shown that using compact representations of intermediate data can dramatically improve bucket elimination for Bayesian inference (?; ?; ?). 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 (?). Compact representations are therefore promising to improve existing dynamic-programming-based algorithms for model counting (?; ?).

In particular, we consider the use of Algebraic Decision Diagrams (ADDs) (?) for model counting in a dynamic-programming framework. An ADD is a compact representation of a real-valued function as a directed acyclic graph. For functions with logical structure, an ADD representation can be exponentially smaller than the explicit representation. ADDs have been successfully used as part of dynamic-programming frameworks for Bayesian inference (?; ?) and stochastic planning (?). Although ADDs have been used for model counting outside of a dynamic-programming framework (?), no prior work uses ADDs for model counting as part of a dynamic-programming framework.

The construction and resultant size of an ADD depend heavily on the choice of an order on the variables of the ADD, 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 (?; ?). 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 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 for Boolean satisfiability of (?) to an ADD-based approach for weighted model counting. 2. 2.

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

We perform an experimental comparison of these heuristic techniques in the context of weighted model counting. 4. 4.

We perform an experimental comparison of ADDMC to four state-of-the-art weighted model counters (Cachet, c2d, d4, and miniC2D) and show that ADDMC improves the virtual best solver on 763 of 1914 benchmarks.

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 formula, which we now define.

Definition 1**.**

Let $\varphi:2^{X}\rightarrow\left\{0,1\right\}$ be a Boolean function over a set $X$ of variables, and let $W:2^{X}\rightarrow\mathbb{R}$ be an arbitrary function. The weighted model count of $\varphi$ w.r.t. $W$ is

[TABLE]

The function $W:2^{X}\rightarrow\mathbb{R}$ 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 $W$ can be expressed, for all $\tau\in 2^{X}$, as

[TABLE]

for some functions $W^{+}(x),W^{-}(x):X\rightarrow\mathbb{R}$. One can interpret these literal-weight functions $W$ as assigning a real-valued weight to each literal: $W^{+}(x)$ to $x$ and $W^{-}(x)$ to $\neg x$. It is common to restrict attention to weight functions whose range is $\mathbb{R}$ or just the interval $[0,1]$.

When the formula $\varphi$ is given in Conjunctive Normal Form (CNF), computing the literal-weighted model count is #P-Complete (?). Several algorithms and tools for weighted model counting directly reason about the CNF representation. For example, Cachet uses DPLL search combined with component caching and clause learning to perform weighted model counting (?).

If $\varphi$ is given in a compact representation — e.g., as a Binary Decision Diagram (BDD) (?) or as a Sentential Decision Diagram (SDD) (?) — 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 miniC2D, which compiles the input CNF formula into an SDD and then performs a polynomial-time count on the SDD (?). Although usually more succinct than a truth table, such compact representations may still be exponential in the size of the CNF formula in the worst case (?).

2.2 Algebraic Decision Diagrams

The central data structure we use in this work is Algebraic Decision Diagram (ADD) (?), a compact representation of a function as a directed acyclic graph. Formally, an ADD is a tuple $(X,S,\pi,G)$, where $X$ is a set of Boolean variables, $S$ is an arbitrary set (called the carrier set), $\pi:X\rightarrow\mathbb{Z}^{+}$ is an injection (called the diagram variable order), and $G$ is a rooted directed acyclic graph satisfying the following three properties. First, every terminal node of $G$ is labeled with an element of $S$. Second, every non-terminal node of $G$ is labeled with an element of $X$ and has two outgoing edges labeled 0 and 1. Finally, for every path in $G$, the labels of the visited non-terminal nodes must occur in increasing order under $\pi$. ADDs were originally designed for matrix multiplication and shortest path algorithms (?). ADDs have also been used for stochastic model checking (?) and stochastic planning (?). In this work, we do not need arbitrary carrier sets; it is sufficient to consider ADDs with $S=\mathbb{R}$.

An ADD $(X,S,\pi,G)$ is a compact representation of a function $f:2^{X}\rightarrow S$. Although there are many ADDs representing each such function $f$, for each injection $\pi:X\rightarrow\mathbb{Z}^{+}$, there is a unique minimal ADD that represents $f$ with $\pi$ 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 $f$ and $g$, the ADDs representing $f+g$ and $f\cdot g$ 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 (BDDs) (?) can be seen as ADDs with carrier set $S=\left\{0,1\right\}$, there is significant overlap with the techniques to find variable orders for BDDs.

Several packages exist for efficiently manipulating ADDs. Here we use the package CUDD (?), which supports carrier sets $S=\left\{0,1\right\}$ and (using floating-point arithmetic) $S=\mathbb{R}$. CUDD implements several ADD operations, such as addition, multiplication, and projection.

3 Using ADDs for Weighted Model Counting with Early Projection

An ADD with carrier set $\mathbb{R}$ can be used to represent both a Boolean formula $\varphi:2^{X}\to\left\{0,1\right\}$ and a weight function $W:2^{X}\to\mathbb{R}$. 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 of Boolean formulas $\varphi$ and weight functions $W$.

3.1 General Weighted Model Counting

We assume that the Boolean formula $\varphi$ and the weight function $W$ are represented as ADDs. The goal is to compute $W(\varphi)$, the weighted model count of $\varphi$ w.r.t. $W$. To do this, we define two operations on functions $2^{X}\to\mathbb{R}$ that can be efficiently computed using the ADD representation: product and projection. These operations are combined in Theorem 1 to perform weighted model counting.

First, we define the product of two functions.

Definition 2**.**

Let $X$ and $Y$ be sets of variables. The product of functions $A:2^{X}\to\mathbb{R}$ and $B:2^{Y}\to\mathbb{R}$ is the function $A\cdot B:2^{X\cup Y}\to\mathbb{R}$ defined for all $\tau\in 2^{X\cup Y}$ by

[TABLE]

Note that the operator $\cdot$ is commutative and associative, and it has the identity element $\mathbf{1}:2^{\varnothing}\to\mathbb{R}$ (that maps $\varnothing$ to $1$). If $\varphi:2^{X}\to\left\{0,1\right\}$ and $\psi:2^{Y}\to\left\{0,1\right\}$ are Boolean formulas, the product $\varphi\cdot\psi$ is the Boolean function corresponding to the conjunction $\varphi\wedge\psi$.

Second, we define the projection of a Boolean variable $x$ in a real-valued function $A$, which reduces the number of variables in $A$ by “summing out” $x$. Variable projection in real-valued functions is similar to variable elimination in Bayesian networks (?).

Definition 3**.**

Let $X$ be a set of variables and $x\in X$. The projection of $A:2^{X}\to\mathbb{R}$ w.r.t. $x$ is the function $\exists_{x}A:2^{X\setminus\left\{x\right\}}\to\mathbb{R}$ defined for all $\tau\in 2^{X\setminus\left\{x\right\}}$ by

[TABLE]

One can check that projection is commutative, i.e., that $\exists_{x}\exists_{y}A=\exists_{y}\exists_{x}A$ for all variables $x,y\in X$ and functions $A:2^{X}\to\mathbb{R}$. If $X=\left\{x_{1},x_{2},\ldots,x_{n}\right\}$, define

[TABLE]

We are now ready to use product and projection to do weighted model counting, through the following theorem.

Theorem 1**.**

Let $\varphi:2^{X}\to\left\{0,1\right\}$ be a Boolean formula over a set $X$ of variables, and let $W:2^{X}\to\mathbb{R}$ be an arbitrary weight function. Then

[TABLE]

Theorem 1 suggests that $W(\varphi)$ can be computed by constructing an ADD for $\varphi$ and another for $W$, computing the ADD for their product $\varphi\cdot W$, and performing a sequence of projections to obtain the final weighted model count. Unfortunately, this “monolithic” approach is infeasible in most interesting cases: the ADD representation of $\varphi\cdot W$ is often too large, even with the best possible diagram variable order.

Instead, we next show a technique for avoiding the construction of an ADD for $\varphi\cdot W$ by rearranging the products and projections.

3.2 Early Projection

A key technique in symbolic computation is early projection: when performing a product followed by a projection (as in Theorem 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 (?), symbolic model checking (?), and satisfiability solving (?). The formal statement is as follows.

Theorem 2** (Early Projection).**

Let $X$ and $Y$ be sets of variables, $A:2^{X}\to\mathbb{R}$, and $B:2^{Y}\to\mathbb{R}$. For all $x\in X\setminus Y$,

[TABLE]

As a corollary, for all $X^{\prime}\subseteq X\setminus Y$,

[TABLE]

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

Assume that $\varphi:2^{X}\to\left\{0,1\right\}$ is a CNF formula, i.e., given as a set of clauses. For every clause $\gamma\in\varphi$, observe that $\gamma$ is a Boolean formula $\gamma:2^{X_{\gamma}}\to\left\{0,1\right\}$ where $X_{\gamma}\subseteq X$ is the set of variables appearing in $\gamma$. One can check using Definition 2 that $\varphi=\prod_{\gamma\in\varphi}\gamma$.

Similarly, assume that $W:2^{X}\to\mathbb{R}$ is a literal-weight function. For every $x\in X$, define $W_{x}:2^{\left\{x\right\}}\to\mathbb{R}$ to be the function that maps $\varnothing$ to $W^{-}(x)$ and $\left\{x\right\}$ to $W^{+}(x)$. One can check using Definition 2 that $W=\prod_{x\in X}W_{x}$.

When $\varphi$ is a CNF formula and $W$ is a literal-weight function, we can rewrite Theorem 1 as

[TABLE]

By taking advantage of the associative and commutative properties of multiplication as well as 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

In this section, we discuss an algorithm for performing literal-weighted model counting of CNF formulas using ADDs through dynamic-programming techniques.

Our algorithm is presented as Algorithm 1. Broadly, our algorithm partitions the clauses of a formula $\varphi$ into clusters. For each cluster, we construct the ADD corresponding to the conjunction of its clauses. These ADDs are then incrementally combined via the multiplication operator. Throughout, each variable of the ADD is projected as early as Theorem 2 allows ($X_{i}$ is the set of variables that can be projected in each iteration $i$ of the second loop). 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 $X_{i}$ at each step $i$.

The function $\texttt{get-clause-ADD}(\gamma,\pi)$ constructs the ADD representing the clause $\gamma$ using the diagram variable order $\pi$. The remaining functions that appear throughout Algorithm 1, namely get-diagram-var-order, get-cluster-var-order, get-clause-rank, and choose-cluster, represent heuristics that can be used to tune the specifics of the algorithm.

Before discussing the various heuristics, we assert the correctness of Algorithm 1 in the following theorem.

Theorem 3**.**

Let $X$ be a set of variables, $\varphi$ be a nonempty CNF formula over $X$, and $W$ be a literal-weight function over $X$. Assume that get-diagram-var-order and get-cluster-var-order return injections $X\rightarrow\mathbb{Z}^{+}$. Furthermore, assume that all get-clause-rank and choose-cluster calls satisfy the following conditions:

$1\leq\texttt{get-clause-rank}(\gamma,\rho)\leq m$, 2. 2.

$i<\texttt{choose-cluster}(A_{i},i)\leq m$, and 3. 3.

$X_{s}\cap\texttt{Vars}(A_{i})=\varnothing$ for all integers $s$ such that $i<s<\texttt{choose-cluster}(A_{i},i)$.

Then Algorithm 1 returns $W(\varphi)$.

By Condition 1, we know the set $\left\{\Gamma_{1},\Gamma_{2},\ldots,\Gamma_{m}\right\}$ forms a partition of the clauses in $\varphi$. Condition 2 ensures that lines 1-1 place $A_{i}$ in a cluster that has not yet been processed. Also on lines 1-1, Condition 3 prevents $A_{i}$ from skipping a cluster $\kappa_{s}$ which shares some variable $y$ with $A_{i}$, as $y$ will be projected at step $s$. These three invariants are sufficient to prove that Algorithm 1 indeed computes the weighted model count of $\varphi$ w.r.t. $W$. All heuristics we describe in this paper satisfy the conditions of Theorem 3.

In the remainder of this section, we discuss a variety of existing heuristics that can be used as a part of Algorithm 1 to implement get-diagram-var-order, get-cluster-var-order, get-clause-rank, and choose-cluster.

4.1 Heuristics for get-diagram-var-order and get-cluster-var-order

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

One simple heuristic for get-diagram-var-order and get-cluster-var-order is to randomly order the variables, i.e., for a formula over some set $X$ of variables, sample an injection $X\rightarrow\left\{1,2,\ldots,|X|\right\}$ 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 $G_{\varphi}$ of a formula $\varphi$. The Gaifman graph of $\varphi$ has a vertex for every variable in $\varphi$. Two vertices are connected by an edge if and only if the corresponding variables appear in the same clause of $\varphi$.

One such heuristic is called Maximum-Cardinality Search (?). At each step of the heuristic, the next variable chosen is the variable adjacent in $G_{\varphi}$ 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 (?). Each vertex of $G_{\varphi}$ is assigned an initially-empty set of vertices (called the label). At each step of the heuristic, the next variable chosen is the variable $x$ whose label is lexicographically smallest among the unchosen variables (breaking ties arbitrarily). Then $x$ is added to the label of its neighbors in $G_{\varphi}$. We call this the LexP heuristic for variable order.

A similar heuristic is called Lexicographic search for minimal orders (?). As before, each vertex of $G_{\varphi}$ is assigned an initially-empty label. At each step of the heuristic, the next variable chosen is again the variable $x$ whose label is lexicographically smallest (breaking ties arbitrarily). In this case, $x$ is added to the label of every variable $y$ where there is a path $x,z_{1},z_{2},\ldots,z_{k},y$ in $G_{\varphi}$ such that every $z_{i}$ is unchosen and the label of $z_{i}$ is lexicographically smaller than the label of $y$. 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 get-clause-rank

The heuristic chosen for get-clause-rank indicates the strategy used for clustering the clauses of $\varphi$. In this work, we consider three possible heuristics to be chosen for get-clause-rank that satisfy the conditions of Theorem 3: Mono, BE, and BM.

One simple case is when the rank of each clause is constant, e.g., when $\texttt{get-clause-rank}(\gamma,\rho)=m$ for all $\gamma\in\varphi$. In this case, all clauses of $\varphi$ are placed in $\Gamma_{m}$, so Algorithm 1 combines all clauses of $\varphi$ into a single ADD before performing projections. This corresponds to the monolithic approach we mentioned earlier. We thus call this the Mono heuristic for get-clause-rank. Notice that the performance of Algorithm 1 with Mono does not depend on the heuristic for get-cluster-var-order or choose-cluster. This heuristic has previously been applied to ADDs in the context of knowledge compilation (?).

Another, more complex heuristic assigns the rank of each clause to be the smallest $\rho$-rank of the variables that appear in the clause. That is, $\texttt{get-clause-rank}(\gamma,\rho)=\min_{x\in\texttt{Vars}(\gamma)}\rho(x)$. This heuristic corresponds to bucket elimination (?), so we call this the BE heuristic. In this case, notice that every clause containing $x\in X$ can only appear in $\Gamma_{i}$ with $i\leq\rho(x)$. It follows that $x$ has always been projected from all clauses by the end of iteration $\rho(x)$ in the second loop of Algorithm 1 using BE.

A related heuristic assigns the rank of each clause to be the largest $\rho$-rank of the variables that appear in the clause. That is, $\texttt{get-clause-rank}(\gamma,\rho)=\max_{x\in\texttt{Vars}(\gamma)}\rho(x)$. This heuristic corresponds to Bouquet’s Method (?), so we call this the BM heuristic. Unlike the BE case, we can make no guarantee about when each variable is projected in Algorithm 1 using BM.

4.3 Heuristics for choose-cluster

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

One heuristic is when choose-cluster selects to place $A_{i}$ in the closest cluster that satisfies the conditions of Theorem 3, namely the next cluster to be processed. That is, $\texttt{choose-cluster}(A_{i},i)=i+1$. Under this heuristic, Algorithm 1 equivalently builds an ADD for each cluster and then combines the ADDs in a one-by-one, in-order fashion, projecting variables as early as possible. In every iteration, there is a single intermediate ADD representing the combination of previous clusters. We call this the List heuristic.

Another heuristic is when choose-cluster selects to place $A_{i}$ in the furthest cluster that satisfies the conditions of Theorem 3. That is, $\texttt{choose-cluster}(A_{i},i)$ returns the smallest $j>i$ such that $X_{j}\cap\texttt{Vars}(A_{i})\neq\varnothing$ (or returns $m$, if $\texttt{Vars}(A_{i})=\varnothing)$. In every iteration, there may be multiple intermediate ADDs representing the combinations 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 cluster $\kappa_{i}$ is a child of cluster $\kappa_{j}$ whenever the ADD produced from $\kappa_{i}$ is placed in $\kappa_{j}$ (lines 1-1). These trees are always left-deep under the List heuristic, but they can be more complex under the Tree heuristic.

We can combine get-clause-rank heuristics and (if applicable) choose-cluster heuristics to form clustering heuristics: Mono, $\textbf{BE}-\textbf{List}$, $\textbf{BE}-\textbf{Tree}$, $\textbf{BM}-\textbf{List}$, and $\textbf{BM}-\textbf{Tree}$.

5 Empirical Evaluation

We implement Algorithm 1 using the ADD package CUDD to produce ADDMC, a new weighted model counter. ADDMC supports all heuristics described in Section 4. The ADDMC source code and experimental data can be obtained from a public repository (https://github.com/vardigroup/ADDMC).

We aim to: (1) find good heuristic configurations for our tool ADDMC, and (2) compare ADDMC against four state-of-the-art weighted model counters: Cachet (?), c2d (?), d4 (?), and miniC2D (?). To accomplish this, we use a set of 1914 CNF literal-weighted model counting benchmarks, which were gathered from two sources.

First, the Bayes class111https://www.cs.rochester.edu/u/kautz/Cachet/ contains 1091 benchmarks. The application domain is Bayesian inference (?). The accompanied literal weights are in the interval $[0,1]$.

Second, the Non-Bayes class222http://www.cril.univ-artois.fr/KC/benchmarks.html contains 823 benchmarks. This benchmark class is subdivided into eight families: Bounded Model Checking (BMC), Circuit, Configuration, Handmade, Planning, Quantitative Information Flow (QIF), Random, and Scheduling (?; ?; ?; ?). All of these benchmarks are originally unweighted. As we focus in this work on weighted model counting, we generate weights by, for each variable $x$, randomly assigning: either weights $W^{+}(x)=0.5$ and $W^{-}(x)=1.5$, or $W^{+}(x)=1.5$ and $W^{-}(x)=0.5$.333 For each variable $x$, Cachet requires $W^{+}(x)+W^{-}(x)=1$ unless $W^{+}(x)=W^{-}(x)=1$. So we use weights 0.25 and 0.75 for Cachet and multiply the model count produced by Cachet on a formula $\varphi$ by $2^{\left|\texttt{Vars}(\varphi)\right|}$ as a postprocessing step.

Generating weights in this particular fashion results in a reasonably low amount of floating-point underflow and overflow for all model counters.

5.1 Experiment 1: Comparing ADDMC Heuristics

ADDMC heuristic configurations are constructed from five clustering heuristics (Mono, BE-List, BE-Tree, BM-List, and BM-Tree) together with seven variable order heuristics (Random, MCS, InvMCS, LexP, InvLexP, LexM, and InvLexM). Using one variable order heuristic for the cluster variable order and another for the diagram variable order gives us 245 configurations in total. We compare these configurations to find the best combination of heuristics.

On a Linux cluster with Xeon E5-2650v2 CPUs (2.60-GHz), we run each combination of heuristics on each benchmark using a single core, 24 GB of memory, and a 10-second timeout.

Performance Analysis

Table 1 reports the numbers of benchmarks solved by four ADDMC heuristic configurations: best, second-best, median, and worst (of 245 configurations in total). Bouquet’s Method (BM) and bucket elimination (BE) have similar-performing top configurations: Best1 and Best2. This shows that Bouquet’s Method is competitive with bucket elimination.

See Figure 1 for a more detailed analysis of the runtime of these four heuristic configurations. Evidently, some configurations perform quite well while others perform quite poorly. The wide range of performance indicates that the choice of heuristics is essential to the competitiveness of ADDMC.

We choose Best1 (BM-Tree clustering with LexP cluster variable order and MCS diagram variable order), which was the heuristic configuration able to solve the most benchmarks within 10 seconds, as the representative ADDMC configuration for Experiment 2.

5.2 Experiment 2: Comparing Weighted Model Counters

In the previous experiment, the ADDMC heuristic configuration able to solve the most benchmarks is Best1 (BM-Tree clustering with LexP cluster variable order and MCS diagram variable order). Using this configuration, we now compare ADDMC to four state-of-the-art weighted model counters: Cachet, c2d444 c2d does not natively support weighted model counting. To compare c2d to weighted model counters, we use c2d to compile CNF into d-DNNF then use d-DNNF-reasoner (http://www.cril.univ-artois.fr/kc/d-DNNF-reasoner.html) to compute the weighted model count. On average, c2d’s compilation time is 81.65% of the total time. , d4, and miniC2D. (We note that Cachet uses long double precision, whereas all other model counters use double precision.)

On a Linux cluster with Xeon E5-2650v2 CPUs (2.60-GHz), we run each counter on each benchmark using a single core, 24 GB of memory and a 1000-second timeout.

Correctness Analysis

To compare answers computed by different weighted model counters (in the presence of imprecision from floating-point arithmetic), we consider non-negative real numbers $a\leq b$ equal when: $b-a\leq 10^{-3}$ if $a=0$ or $b\leq 1$, and $b/a\leq 1+10^{-3}$ otherwise.

Even with this equality tolerance, weighted model counters still sometimes produce different answers for the same benchmark due to floating-point effects. In particular, of 1008 benchmarks that are solved by all five model counters, ADDMC produces 7 model counts that differ from the output of all four other tools. For Cachet, c2d, d4, and miniC2D, the numbers are respectively 55, 0, 42, and 0. To improve ADDMC’s precision, we plan as future work to integrate a new decision diagram package, Sylvan (?), into ADDMC. Sylvan can interface with the GNU Multiple Precision library to support ADDs with higher-precision numbers.

Performance Analysis

Table 2 summarizes the performance of five weighted model counters (Cachet, ADDMC, miniC2D, c2d, and d4) as well as two virtual best solvers (VBS). For each benchmark, the solving time of VBS1 is the shortest solving time among all five actual solvers. Similarly, the time of VBS0 is the shortest time among four actual solvers, excluding ADDMC. Note that ADDMC uniquely solves 124 benchmarks (that are solved by no other tool). Additionally, ADDMC is the fastest solver on 639 other benchmarks. So ADDMC improves the solving time of VBS1 on 763 benchmarks in total.

See Figure 2 for a more detailed analysis of the runtime of all solvers. Evidently, VBS1 (with ADDMC) performs significantly better than VBS0 (without ADDMC). We conclude that ADDMC is a useful addition to the portfolio of weighted model counters.

Predicting ADDMC Performance

Generally, ADDMC can solve a benchmark quickly if all intermediate ADDs constructed during the model counting process are small. An ADD is small when it achieves high compression under a good diagram variable order; predicting this a priori is difficult and is an area of active research. However, an ADD also tends to be small if it has few variables, which occurs when an ADDMC heuristic configuration results in many opportunities for early projection. Moreover, the number of variables that occur in each ADD produced by Algorithm 1 can be computed much faster than computing the full model count (since we do not need to actually construct the ADDs).

Formally, fix an ADDMC heuristic configuration. For a given benchmark, define the maximum ADD variable count (MAVC) to be the largest number of variables across all ADDs that would be constructed when running Algorithm 1. Using the heuristic configuration of Experiment 2 (Best1), we were able to compute the MAVCs of 1906 benchmarks (of 1914 in total). We were unable to compute the MAVCs of the remaining 8 benchmarks within 10000 seconds due to the large number of variables and clauses; these benchmarks were also not solved by ADDMC.

Figure 3 shows the number of benchmarks solved by ADDMC in Experiment 2 for various upper bounds on the MAVC. Generally, ADDMC performed well on benchmarks with low MAVCs. In particular, ADDMC solved most benchmarks (1345 of 1425) with MAVCs less than 70 but solved solved few benchmarks (12 of 379) with MAVCs greater than 100.

Figure 4 shows the runtime of ADDMC on the 1404 benchmarks ADDMC was able to solve in Experiment 2. In general, ADDMC was slower on benchmarks with higher MAVCs.

From these two observations, we conclude that the MAVC of a benchmark (under a particular heuristic configuration) is a good predictor of ADDMC performance.

6 Discussion

In this work, 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 weighted model counter. We used ADDMC to compare bucket elimination and Bouquet’s Method across a variety of variable order heuristics on 1914 standard model counting benchmarks and concluded that Bouquet’s Method is competitive with bucket elimination.

Moreover, we demonstrated that ADDMC is competitive with existing state-of-the-art weighted model counters on these 1914 benchmarks. In particular, adding ADDMC allows the virtual best solver to solve 124 more benchmarks. Thus ADDMC is valuable as part of a portfolio of solvers, and ADD-based approaches to model counting in general are promising and deserve further study. One direction for future work is to investigate how benchmark properties (e.g., treewidth) correlate with the performance of ADD-based approaches to model counting. Predicting the performance of tools on CNF benchmarks is an active area of research in the SAT solving community (?).

Bucket elimination has been well-studied theoretically, with close connections to treewidth and tree decompositions (?; ?). On the other hand, Bouquet’s Method is much less well-known. Another 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 ADD package CUDD. There are other ADD packages that may be fruitful to explore in the future. For example, Sylvan (?) supports multicore operations on ADDs, which would allow us to investigate the impact of parallelism on our techniques. Moreover, Sylvan supports arbitrary-precision arithmetic.

Several other compact representations have been used in dynamic-programming frameworks for related problems. For example, AND/OR Multi-Valued Decision Diagrams (?), Probabilistic Sentential Decision Diagrams (?), and Probabilistic Decision Graphs (?) have all been used for Bayesian inference. Moreover, weighted decision diagrams have been used for optimization (?), and Affine Algebraic Decision Diagrams have been used for planning (?). It would be interesting to see if these compact representations also improve dynamic-programming frameworks for model counting.

Acknowledgments

The authors would like to thank Dror Fried, Aditya A. Shrotri, and Lucas M. Tabajara for useful comments. This work was supported in part by the NSF (grants CNS-1338099, IIS-1527668, CCF-1704883, IIS-1830549, and DMS-1547433), 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/2018 Cray Graduate Fellowship, and by Rice University.

Appendix A ADD Graphical Example

Figure 5 is a graphical example of an ADD.

Appendix B Proofs

B.1 Proof of Theorem 1

Proof.

Assume the variables in $X$ are $x_{1},x_{2},\ldots,x_{n}$. Now, for an arbitrary function $A:2^{X}\to\mathbb{R}$, we have:

[TABLE]

Similarly, projecting all variables in $X$:

[TABLE]

When $A$ is the specific function $\varphi\cdot W:2^{X}\to\mathbb{R}$, we have:

[TABLE]

Finally:

[TABLE]

∎

B.2 Proof of Theorem 2

Proof.

For every $\tau\in 2^{(X\cup Y)\setminus\left\{x\right\}}$, we have:

[TABLE]

∎

B.3 Proof of Theorem 3

In order to prove Theorem 3, we first state and prove two invariants that hold during the loop at line 1 of Algorithm 1.

First, we prove in the following lemma that the variables in $X_{i}$ never appear in the clusters $\kappa_{j}$ for every $i<j$.

Lemma 1**.**

Assume the conditions of Theorem 3. At every step of the loop at line 1 of Algorithm 1 and for every $1\leq i<j\leq m$, $X_{i}\cap\texttt{Vars}(\kappa_{j})=\varnothing$.

Proof.

We prove this invariant by induction on the steps of the algorithm. The base case (i.e., immediately before line 1) follows from the initial construction of $X_{i}$.

During the loop, the only potential problem is at line 1. In particular, consider an iteration $i<m$ where some ADD $A_{i}$ is added to $\kappa_{j}$ (where $j=\texttt{choose-cluster}(A_{i},i)$) and assume that the invariant holds before line 1. To prove that the invariant still holds after line 1, consider some $1\leq s<j$. We prove by cases that $X_{s}\cap\texttt{Vars}(A_{i})=\varnothing$:

• •

Case $s<i$. By the inductive hypothesis, we have $X_{s}\cap\texttt{Vars}(\kappa_{i})=\varnothing$. Since $\texttt{Vars}(A_{i})\subseteq\texttt{Vars}(\kappa_{i})$, it follows that $X_{s}\cap\texttt{Vars}(A_{i})=\varnothing$.

• •

Case $s=i$. All variables in $X_{i}$ are projected from $A_{i}$ during the loop at line 1. Thus $X_{i}\cap\texttt{Vars}(A_{i})=\varnothing$.

• •

Case $s>i$. Since $s<j$, it follows from Condition 3 of Theorem 3 that $X_{s}\cap\texttt{Vars}(A_{i})=\varnothing$.

By the inductive hypothesis, $X_{i}\cap\texttt{Vars}(B)=\varnothing$ for all other $B\in\kappa_{j}$. Hence $X_{i}\cap\texttt{Vars}(\kappa_{j})=\varnothing$. ∎

Next, we use this invariant prove that the ADDs in $\bigcup_{j\geq i}\kappa_{j}$ always contain sufficient information to compute the weighted model count at iteration $i$.

Lemma 2**.**

Assume the conditions of Theorem 3 and let $Y_{i}=\bigcup_{j\geq i}X_{i}$. At the start of every iteration $i$ of the loop at line 1 of Algorithm 1,

[TABLE]

Proof.

We prove this invariant by induction on $i$.

We first consider iteration $i=1$. It follows from Condition 1 of Theorem 3 that $\bigcup_{j\geq 1}\Gamma_{j}=\varphi$. Thus $Y_{1}=\texttt{Vars}(\varphi)=X$ and moreover $\prod_{j\geq 1}\prod_{B\in\kappa_{j}}B=\prod_{\gamma\in\varphi}\texttt{get-clause-ADD}(\gamma,\pi)$. Equation 2 therefore follows directly from Theorem 1.

Next, assume that Equation 2 holds at the start of some iteration $i<m$ and consider Equation 2 at the start of iteration $i+1$. For convenience, let $\kappa_{j}$ refer to its value at the start of iteration $i$ and let $\kappa_{j}^{\prime}$ refer to the value of $\kappa_{j}$ at the start of iteration $i+1$ (for all $j\geq i$).

If $\kappa_{i}=\varnothing$, then $\kappa_{i}$ does not contribute to Equation 2, so Equation 2 remains unchanged (and thus still holds) at the start of iteration $i+1$. If $\kappa_{i}\neq\varnothing$, then after lines 10-12 Algorithm 1 computes $A_{i}=\exists_{X_{i}}\left(\prod_{D\in\kappa_{i}}D\cdot\prod_{x\in X_{i}}W_{x}\right)$ (using Theorem 2 to rearrange terms). By Condition 2 of Theorem 3, $A_{i}$ is then placed in $\kappa_{j}^{\prime}$ for some $i<j\leq m$. Therefore, at the start of iteration $i+1$ we have

[TABLE]

Plugging in the value of $A_{i}$, this is equal to

[TABLE]

Notice $Y_{i}$ is the disjoint union of $Y_{i+1}$ and $X_{i}$. Thus $X_{i}\cap\texttt{Vars}(W_{x})=\varnothing$ for all $x\in Y_{i+1}$. Moreover, by Lemma 1 $X_{i}\cap\texttt{Vars}\left(\prod_{j\geq i+1}\prod_{B\in\kappa_{j}}B\right)=\varnothing$. It thus follows from Theorem 2 that

[TABLE]

By the inductive hypothesis, this ADD is exactly $W(\varphi)$ when evaluated at $\varnothing$. It follows that Equation 3 holds at the start of iteration $i+1$ as well. ∎

Given this second invariant, the proof of Theorem 3 is straightforward.

Proof.

By Lemma 2, at the start of iteration $m$ we know that

[TABLE]

Since

[TABLE]

it follows that line 1 returns $W(\varphi)$. ∎