Knowledge Compilation for Model Counting: Affine Decision Trees

1 Introduction

Model counting is a key issue in a number of AI problems, including inference in Bayesian networks and contingency planning [Littman et al., 2001; Bacchus et al., 2003; Sang et al., 2005; Darwiche, 2009]. However, this problem is computationally hard (#P-complete) [Valiant, 1979]. Accordingly, few propositional languages offer the possibility to count models exactly in an efficient way [Roth, 1996].

The knowledge compilation (KC) map, introduced by Darwiche and Marquis [2002] and enriched by several authors (see among others [Wachter and Haenni, 2006; Subbarayan et al., 2007; Mateescu et al., 2008; Fargier and Marquis, 2008; Darwiche, 2011; Marquis, 2011; Bordeaux et al., 2012]) is a multi criteria evaluation of languages, where languages are compared according to the queries and the transformations they support in polynomial time, as well as their relative succinctness (i.e., their ability to represent information using little space).

∗This work is partially supported by FWF, NFN Grant S11408N23 (RiSE), and by the project BR4CP ANR-11-BS02-008 of the French National Agency for Research.

Among the languages which have been studied and classified according to the KC map, only the language d-DNNF of formulae in deterministic decomposable negation normal form [Darwiche, 2001], together with is subsets OBDD< [Bryant, 1986], FBDD [Gergov and Meinel, 1994], and SDD [Darwiche, 2011], satisfy the CT query (model counting). Yet, another interesting language which satisfies CT is AFF, the set of all affine formulae [Schaefer, 1978], defined as finite conjunctions of affine clauses (aka XOR-clauses). Unfortunately, AFF is not a complete language, because some propositional formulae (e.g. the clause x ∨ y) cannot be represented into conjunctions of affine clauses.

By coupling ideas from affine formulae and decision trees, this paper introduces a new family of propositional languages that are complete and satisfy CT. The blueprint of our family is the class EADT of extended affine decision trees. In essence, an extended affine decision tree is a tree with decision nodes and some specific decomposable conjunction or disjunction nodes. Unlike usual decision trees, the decision nodes in an EADT are labeled by affine clauses instead of variables. Our family covers several subsets of EADT, including ADT (the set of affine decision trees where conjunction or disjunction nodes are prohibited), EDT (the set of extended decision trees where decomposable conjunction or disjunction nodes are allowed but decision nodes are mainly restricted to standard ones), and DT, the intersection of ADT and EDT.

Following the lines of the KC map, we prove that ADT and its subclass DT satisfy all queries and transformations offered by ordered binary decision diagrams (OBDD<). Analogously, EADT and its subclass EDT satisfy all queries offered by d-DNNF and more transformations (¬C is not satisfied by d-DNNF). Importantly, we also show that none of OBDD<, CNF, and DNF is at least as succinct as any of ADT or EADT, and that EADT is strictly more succinct than ADT.

Finally, we describe a CNF-to-EADT compiler (which can be downsized to a compiler targeting ADT, EDT or DT). We used this program to compile a number of benchmarks from different domains. This empirical evaluation aimed at addressing two practical issues: (1) how challenging is an EADT compilation-based approach to model counting, compared to a direct, uncompiled method using a state-of-the-art model counter? (2) how does the EADT compilation-based approach perform compared to a d-DNNF compilation-based method? Our experimental results show that the EADT compilationbased approach is competitive with both methods and, in some cases, it really outperforms them.

The rest of the paper is organized as follows. After introducing some background in Section 2, EADT and its subsets are defined and examined along the lines of the KC map in Section 3. In Section 4, our compiler is described and, in Section 5, some empirical results are presented and discussed. Finally, Section 6 concludes the paper. The run-time code of our compiler can be downloaded at http://www.cril.fr/ADT/

2 Preliminaries

We assume the reader familiar with propositional logic (including the notions of model, consistency, validity, entailment, and equivalence). All languages examined in this study are defined over a finite set PS of Boolean variables, and the constants ⊤ (true) and ⊥ (false).

Affine Formulae. Let PS be a denumerable set of propositional variables. A literal (over PS) is an element x ∈ PS (a positive literal) or a negated one ¬x (a negative literal), or a Boolean constant ⊤ (true) or ⊥ (false). An affine clause (aka XOR-clause) δ is a finite XOR-disjunction of literals (the XOR connective is denoted by ⊕). var(δ) is the set of variables occurring in δ. δ is unary when it contains precisely one literal. Obviously enough, each affine clause can be rewritten in linear time as a simplified affine clause, i.e., a finite XORdisjunction of positive literals occurring once in the formula, plus possibly one occurrence of ⊤ (just take advantage of the fact that ⊕ is associative and commutative, and of the equivalences ¬x ≡ x ⊕ ⊤, x ⊕ x ≡ ⊥, x ⊕ ⊥ ≡ x, viewed as rewrite rules, left-to-right oriented). For instance, the affine clause ¬x ⊕ x ⊕ ¬y ⊕ ¬z can be turned in linear time into the equivalent simplified affine clause y ⊕ z ⊕ ⊤. An affine formula is a finite conjunction of affine clauses.

Knowledge Compilation. For space reasons, we assume the reader has a basic familiarity with the languages CNF, DNF, OBDD<, SDD, BDD, FBDD, d-DNNFT, d-DNNF, and DAG-NNF, which are considered in the following (see [Darwiche and Marquis, 2002; Pipatsrisawat and Darwiche, 2008; Darwiche, 2011] for formal definitions). The basic queries considered in the KC map include tests for consistency CO, validity VA, implicates (clausal entailment) CE, implicants IM, equivalence EQ, sentential entailment SE, model counting CT, and model enumeration ME. The basic transformations are conditioning (CD), (possibly bounded) closures under the connectives (∧C, ∧BC, ∨C, ∨BC, ¬C), and forgetting (FO, SFO).

Finally, let L1 and L2 be two propositional languages.

• L1 is at least as succinct as L2, denoted L1 ≤s L2, iff there exists a polynomial p such that for every formula φ ∈ L2, there exists an equivalent formula ψ ∈ L1 where |ψ| ≤ p(|φ|).
• L1 is polynomially translatable into L2, noted L1 ≥p L2, iff there exists a polynomial-time algorithm f such that for every φ ∈ L1, f(φ) ∈ L2 and f(φ) ≡ φ.
• <s is the asymmetric part of ≤s, i.e., L1 <s L2 iff L1 ≤s L2 and L2 ̸≤s L1. When L1 ≥p L2 holds, every query which

is supported in polynomial time in L2 also is supported in polynomial time in L1; conversely, every query which is not supported in polynomial time in L1 unless P = NP is not supported in polynomial time in L2, unless P = NP.

3 The Affine Family

All propositional languages in our family are subsets of the very general language of affine decision networks:

Definition 1 ADN is the set of all affine decision networks, defined as single-rooted finite DAGs where leaves are labeled by a Boolean constant (⊤ or ⊥), and internal nodes are ∧ nodes or ∨ nodes (with arbitrarily many children) or affine decision nodes, i.e., binary nodes of the form N = 〈δ,N-,N+〉 where δ is the affine clause labeling N and N(resp. N+) is the left (resp. right) child of N.

The size |∆| of an ADN formula ∆ is the sum of number of arcs in it, plus the cumulated size of the affine clauses used as labels in it. For every node N in an ADN formula ∆, Var(N) is defined inductively as follows:

• if N is a leaf node, then Var(N) = ∅;
• if N is an affine decision node N = 〈δ,N-,N+〉, then Var (N) = var (δ) ∪ Var (N-) ∪ Var (N+);
• ifN is a∧node (resp. ∨node) with childrenN1,. . .,Nk, then Var (N) = ⋃ki=1 Var (Ni).

Clearly, Var(∆) = Var(R∆) (where R∆ is the root of ∆) can be computed in time linear in the size of ∆. Every ADN formula ∆ is interpreted as a propositional formula I(∆) over Var(∆), where I(∆) = I(R∆) is defined inductively as:

• if N is a leaf node labeled by ⊤ (resp. ⊥), then I(N) = ⊤ (resp. ⊥);
• if N is an affine decision node N = 〈δ,N-,N+〉, then I(N) = ((δ ⊕ ⊤) ∧ I(N-)) ∨ (δ ∧ I(N+));
• ifN is a∧node (resp. ∨node) with childrenN1,. . . ,Nk, then I(N) = ∧ki=1 I(Ni) (resp. ∨ki=1 I(Ni)).

Finally, ‖∆‖ represents the number of models of the ADN formula ∆ over Var (∆).

The DAG-NNF language considered in [Darwiche and Marquis, 2002] is polynomially translatable into a subset of ADN, where decision nodes have leaf nodes as children. Indeed, every leaf node labeled by a positive literal x (resp. negative literal ¬x) in a DAG-NNF formula is equivalent to the affine decision node N labeled by δ = x and such that N- = ⊥ (resp. = ⊤) and N+ = ⊤ (resp. = ⊥). Thus, ADN is a highly succinct yet intractable representation language; especially, it does not satisfy the CT query unless P = NP. To this point, we need to focus on tractable subsets of ADN.

Let us start with the EADT language, a class of treestructured formulae defined in term of affine decomposability. Formally, a ∧ (resp. ∨) node N with children N1, . . . ,Nk in an ADN ∆ is said to be affine decomposable if and only if:

1. for any i, j ∈ 1,. . . , k, if i ̸= j, then Var(Ni) ∩ Var(Nj) = ∅, and

1. for every affine decision node N ′ of ∆ which is a parent node of N and which is labelled by the affine clause δN ′ , at most one child Ni of N is such that var (δN ′ ) ∩ Var (Ni) ̸= ∅.

If only the first condition holds, then the node N is said to be (classically) decomposable.

Definition 2 EADT is the set of all extended affine decision trees, defined as finite trees where leaves are labeled by a Boolean constant (⊤ or ⊥), and internal nodes are affine decision nodes, or affine decomposable ∧ nodes, or affine decomposable ∨ nodes.

An example of EADT formula is given at Figure 1. Some relevant subclasses of EADT are defined as follows:

Definition 3

• ADT is the set of all affine decision trees, i.e., the subset of EADT consisting of finite trees where leaves are labeled by a Boolean constant (⊤ or ⊥), and internal nodes are affine decision nodes.
• EDT is the set of all extended decision trees, i.e., the subset of EADT where affine decision nodes are labeled by unary affine clauses. 1
• DT, the set of all decision trees, is the intersection of ADT and EDT.

Based on this family, it is easy to check that the language TE of all terms and the language CL of all clauses are linearly translatable into DT, and hence, into each of ADT, EDT, and EADT. Furthermore, the language AFF is also polynomially translatable into ADT (hence into its superset EADT).

In contrast to TE, CL, and AFF, the class DT and its supersets ADT, EDT, and EADT are complete propositional languages. The completeness property also holds for ODT<, which is the subset of DT consisting of formulae ∆ in which every path from the root of ∆ to a leaf respects the given, total, strict ordering < (i.e., the variables labeling the decision nodes in the path are ordered in a way which is compatible with <). Clearly, ODT< also is a subset of OBDD< (to be more precise, ODT< is the intersection of DT and OBDD<), and both CL and TE are polynomially translatable to it.

1 The affine decomposability condition can be given up for EDT formulae since every EDT formula can be translated in linear time into an equivalent EDT formula which is read-once (i.e., for every path from the root of the tree to a leaf, the list of all variables labeling the decision nodes of the path contains at most one occurrence of each variable).

We are now in position to explain how any EADT formula ∆ can be translated in linear time into a tree T(∆) where internal nodes are decomposable ∧ nodes or decomposable ∨ nodes or deterministic binary ∨ nodes, and the leaves are labeled with affine formulae. The translation T consists in rewriting ∆ by parsing it in a top-down way, and collecting sets of affine clauses (those sets are the values of an inherited attribute a defined for each node N of ∆) along the paths of ∆ during the translation. T proceeds recursively as follows starting with N = R∆ and a(R∆) = ∅:

• if N = 〈δ,N-,N+〉, then T(N) = T(N-) ∨ T(N+), a(N-) = a(N) ∪ {δ ⊕ ⊤}, and a(N+) = a(N) ∪ {δ};
• if N = ∧ki=1 Ni, then T(N) = ∧ki=1 T(Ni), and for every i ∈ 1, . . . , k, a(Ni) = {δ ∈ a(N) | var(δ) ∩ Var(Ni) ̸= ∅};
• if N = ∨ki=1 Ni, then T(N) = ∨ki=1 T(Ni), and for every i ∈ 1, . . . , k, a(Ni) = {δ ∈ a(N) | var(δ) ∩ Var(Ni) ̸= ∅};
• if N = ⊤, then T(N) = ∧δ∈a(N) δ;
• if N = ⊥, then T(N) = ⊥.

By construction, the translation T consists in replacing every affine decision node by a deterministic binary ∨ node, every affine decomposable ∧ (resp. ∨) node by a (classically) decomposable ∧ (resp. ∨) node. Thus, when ∆ is an ADT formula, T(∆) simply is a deterministic disjunction of affine formulae, and when ∆ is a DT formula, T(∆) simply is a deterministic DNF formula.

With this translation in hand, it is easy to show that EADT satisfies CT. The proof is by structural induction on φ = T(∆). First, ‖φ‖ can be computed in polynomial time when φ is an affine formula, since φ can be viewed as a finite system of linear equations modulo 2. Indeed, φ can be turned in polynomial time into its equivalent reduced row echelon form φr , and when Var(φr ) contains n variables and φr contains k affine clauses, ‖φ‖ is equal to 2n-k . This solves the base case. As to the inductive step, it is enough to check that:

• if φ = ∧ki=1 φi (where ∧ is a decomposable ∧ node),

• if φ = ∨ki=1 φi (where ∨ is a decomposable ∨ node),

• if φ = φ1 ∨φ2 (where ∨ is a deterministic ∨ node), then ‖φ‖=‖φ1‖×2|Var(φ2)\Var(φ1)|+‖φ2‖×2|Var(φ1)\Var(φ2)|

More generally, our results concerning queries and transformations of the KC map are summarized in Proposition 1. Languages d-DNNF and OBDD< (which are not subsets of EADT) are reported for the comparison matter.

Proposition 1 The results given in Tables 1 and 2 hold.

In a nutshell, ADT and its subclass DT are equivalent to OBDD< with respect to queries and transformations. Similarly, EADT and its subclass EDT are essentially equivalent to d-DNNF with respect to queries and transformations. In particular, EDT, EADT, and d-DNNF do not satisfy SE unless P = NP, and it is unknown whether they satisfy EQ. It is also unknown whether d-DNNF satisfies ¬C, but this transformation can be done in linear time for both EADT and EDT.

The inclusion graph of the different languages is given in Figure 2. In light of this inclusion graph and the fact that DT (resp. EDT) does not satisfy more queries or transformations than ADT (resp. EADT), it follows that DT (resp. EDT) cannot prove a better choice than ADT (resp. EADT) from the KC point of view. This is why we focus on ADT and EADT in the following. For these languages, we obtained the following succinctness results:

Proposition 2 CNF ̸≤s ADT, DNF ̸≤s ADT, OBDD< ̸≤s ADT, d-DNNFT ̸≤s ADT, and EADT <s ADT.

Based on these results, it turns out that OBDD< does not dominate ADT from the KC point of view (i.e., it does not offer any query/transformation not supported by ADT, and is not strictly more succinct than ADT). This, together with the fact that ADT ⊆ EADT implies that OBDD< does not dominate EADT. Our succinctness results also reveal that none of the "flat" languages CNF and DNF is at least as succinct as any of ADT or EADT. Although we ignore how d-DNNF and EADT compare w.r.t. succinctness, we know that the subclass d-DNNFT does not dominate any of ADT or EADT.

4 A CNF-to-EADT Compiler

A natural approach for compiling an arbitrary propositional formula into an EADT formula is to exploit a generalized form of Shannon expansion. Given two formulae ∆ and δ, and a variable x, we denote by ∆ |x←δ the formula obtained by replacing every occurrence of x in ∆ by δ. With this notation in hand, the generalized Shannon expansion states that for every propositional formulae ∆ and δ and every variable x, we have:

Observe that the standard expansion introduced by Shannon [1949] is recovered by considering δ = ⊤. The validity of the generalized expansion comes from the fact that ∆ is equivalent to ((x ⇔¬δ) ∧∆) ∨ ((x ⇔ δ) ∧∆), and the fact that, for every propositional formula δ (or its negation), the expression (x ⇔ δ) ∧ ∆ is equivalent to (x ⇔ δ) ∧ ∆ |x←δ .

In our setting, ∆ is an ECNF formula and δ is an affine clause. ECNF, the language of extended CNF, is the set of all finite conjunctions of extended clauses, where an extended clause is a finite disjunction of affine clauses. Thus, for instance, x1 ∨ (x2 ⊕x3 ⊕⊤) ∨ (x1 ⊕x3) is an extended clause. Clearly, CNF is linearly translatable into ECNF Now, since x ⇔ ¬δ is equivalent to x ⊕ δ, and x ⇔ δ is equivalent to x⊕δ⊕⊤, the generalized Shannon expansion can be restated as the following branching rule:

The Compilation Algorithm. Based on previous considerations, Algorithm 1 provides the pseudo-code for the compiler eadt, which takes as input an ECNF formula ∆, and returns as output an EADT formula equivalent to ∆. The first two lines deal with the specific cases where ∆ is valid or unsatisfiable. In both cases, the corresponding leaf is returned.

We note in passing that the unsatisfiability problem (resp. the validity problem) for ECNF has the same complexity as for its subset CNF, i.e., it is coNP-complete (resp. it is in P). This is obvious for the unsatisfiability problem. For the validity problem, an ECNF formula is valid iff every extended clause in it is valid, and an extended clause δ1∨. . .∨δk (where each δi, i ∈ 1, . . . , k is an affine clause) is valid iff the affine formula (δ1 ⊕⊤) ∧ . . . ∧ (δk ⊕⊤) is contradictory, which can be tested in polynomial time.

In the remaining case, ∆ is split into a decomposable conjunction of components ∆1, · · · ,∆k (Line 3). These components are recursively compiled into EADT formulae and conjoined as a ∧ node using the aNode function. Note that decomposition takes precedence over branching: only when ∆ consists of a single component, the compiler chooses an affine clause x ⊕ δ for which all variables occur in ∆ (Line 5), and then branches on this clause using the generalized Shannon

Algorithm 1: eadt(∆)

input : an ECNF formula ∆

output: an EADT formula equivalent to ∆

• 1 if ∆≡ ⊤ then return leaf(⊤)
• 2 if ∆≡ ⊥ then return leaf(⊥)

3 let ∆1, · · · ,∆k be the connected components of ∆

• 4 if k > 1 then return aNode(eadt(∆1), · · · , eadt(∆k))

5 choose a simplified affine clause x ⊕ δ such that

expansion (Line 6). Here, the dNode function returns a decision node labeled with the first argument, having the second argument as left child, and having the third argument as right child. When Line 3 is omitted, the CNF-to-EADT compiler boils down to a CNF-to-ADT compiler.

Algorithm 1 is guaranteed to terminate. Indeed, by definition of a simplified affine clause, δ in x ⊕ δ is an affine clause which does not contain x. Since none of ∆ |x←δ⊕⊤ and ∆ |x←δ contains x, the steps 5 and 6 can be applied only a finite number of times. Furthermore, the EADT formula returned by the algorithm is guaranteed to satisfy the affine decomposition rule. This property can be proved by induction on the structure of the resulting tree: the only non-trivial case is when the tree consists of a ∧ node with parents N and children N1, · · · ,Nk each Ni formed by calling eadt on the connected component ∆i of the formula ∆. Since each parent clause in N is of the form x ⊕ δ, where x is excluded from δ, and since the components do not share any variable, it follows that x ⊕ δ overlaps with at most one component in ∆1, · · · ,∆k. This, together with the fact that the generalized Shannon expansion is valid, establishes the correctness of the algorithm.

Implementation. Algorithm 1 was implemented on top of the state-of-the-art SAT solver MiniSAT [E´en and S¨orensson, 2003]. We extended MiniSAT to deal with ECNF formulae. The heuristic used at Line 5 for choosing affine clauses of the form x ⊕ δ is based on the concept of variable activity (VSIDS, Variable State Independent Decaying Sum) [Moskewicz et al., 2001]. Specifically, for each extended clause C of ∆, the score of C is computed as the sum of the scores of each affine clause in it, where the score of an affine clause is the the sum of the VSIDS scores of its variables. Based on this metric, an extended clause C of ∆ of maximal score is selected, and the variables of C are sorted by decreasing VSIDS score; the selected variable x is the first variable in the resulting list, and the affine clause δ is formed by the next k - 1 variables in the list. Note that selecting all the variables of x ⊕ δ from the same extended clause C of ∆ prevents us from generating connections between variables which are not already connected in the constraint graph of ∆. We also took advantage of a simple filtering method, which consists in finding implied affine clauses, used only at the first top nodes of the search tree. In our experiments, we bounded the size of affine clauses to k = 2, and used the filtering method up to depth 5.

5 Experiments

Setup. The empirical protocol we followed is very close to the one conducted in [Schrag, 1996] (and other papers). We have considered a number of CNF benchmark instances from different domains provided by the SAT LIBrary (www.cs.ubc. ca/∼hoos/SATLIB/index-ubc.html). For each CNF instance ∆, we generated 1000 queries; each query is a 3-literal term γ the 3 variables of which are picked up at random from the set of variables of ∆, following a uniform distribution; the sign of each literal is also selected at random with probability 12 . The objective is to count the number of models of the conditioned formula ∆ | γ for all queries γ. Our experiments have been conducted on a Quad-core Intel XEON X5550 with 32Gb of memory. A time-out of 3 hours has been considered for the off-line compilation phase, and a time-out of 3 hours per query has been established for addressing each of the 1000 queries during the on-line phase. Based on this setup, three approaches have been examined:

• A direct, uncompiled approach: we considered a state-of-the-art model counter, namely Cachet (www. cs.rochester.edu/∼kautz/Cachet/index.htm) [Sang et al., 2004]. Here, #FCachet is the number of elements of FCachet, the set of "feasible" queries, i.e., the queries in the sample for which Cachet has been able to terminate before the time-out (or a segmentation fault). QCachet gives the mean time needed to address the feasible queries, i.e.,

where QCachet(∆|γ) is the runtime of Cachet for ∆|γ.

• Two compilation-based approaches: d-DNNF and EADT have been targeted. We took advantage of the c2d compiler (reasoning.cs.ucla.edu/c2d/) to generate (smooth) d-DNNF compilations, 2 and our own compiler to compute EADT compiled forms. For each L among d-DNNF and EADT, ∆ has been first turned into a compiled form ∆∗ ∈ L during an off-line phase. The compilation time CL needed to compute ∆∗ and the mean queryanswering time QL have been measured. We also computed for each approach two ratios:

Intuitively, αL indicates how much on-line time improvement is got from compilation: the lower the better. The quantity βL captures the number of queries needed to amortize compilation time. Clearly, the compilationbased approach targeting L is useful only if αL < 1. By convention, βL = +∞ when αL ≥ 1.

2 Primarily, we also planned to use the d-DNNF compiler Dsharp [Muise et al., 2012] but unfortunately, we encountered the same problems as mentioned in [Voronov, 2013] to run it, which prevented us from doing it.

Results. Table 3 presents the obtained results. Each line corresponds to a CNF instance ∆ identified by the leftmost column. The first two columns give respectively the number #var of variables of ∆ and the number #cla of clauses of ∆, and the remaining columns give the measured values. The reported computation times are in seconds.

We can observe that both compilation-based approaches typically prove valuable whenever the off-line compilation phase terminates. On the one hand, for each compilationbased approach L, all the 1000 queries have been "feasible" when the compilation process terminated in due time. For this reason, we did not report in the table the number #FL of feasible queries. By contrast, the number of feasible queries for the direct, uncompiled approach is sometimes significantly lower than 1000, and the standard deviation of the on-line query-answering time (not given in the table for space reasons) for such queries is often significantly greater than the corresponding deviations measured from compilation-based approaches. On the other hand, the number of queries β to be considered for balancing the compilation time is finite for all, but two (one for d-DNNF and one for EADT), instances.

Furthermore, the experiments revealed that some instances of significant size are compilable. When the compilation succeeds, β is typically small and, accordingly, on-line time savings of several orders of magnitude can be achieved. Especially, the optimal value 1 for the "break-even" point β has been reached for many instances when the EADT language was targeted. This means that in many cases the off-line time spend to built the EADT compiled form is immediately balanced by the first counting query. Stated otherwise, the eadt compiler proves also competitive as a model counter.

Finally, our experiments show EADT compilation challenging with respect to d-DNNF compilation in many (but not all) cases. When compilation succeeds in both cases, the number of nodes in EADT and d-DNNF formulae are about the same order, but the EADT formulae are slightly faster for processing queries, due to their arborescent structure.

6 Conclusion

The propositional language EADT introduced in the paper appears as quite appealing for the representation purpose, when CT is a key query. Especially, EADT offers the same queries as d-DNNF, and more transformations (among those considered in the KC map). The subset ADT of EADT offers all the queries and the same transformations as those satisfied by the influential OBDD< language. Furthermore, OBDD< is not at least as succinct as ADT, which shows ADT as a possible challenger to OBDD<. In practice, the EADT compilation-based approach to model counting appears as competitive with the model counter Cachet and the d-DNNF compilation-based approach to model counting.

This work opens a number of perspectives for further research. From the theoretical side, a natural extension of ADT is the set of all single-rooted finite DAGs, where leaves are labeled by a Boolean constant (⊤ or ⊥), and internal nodes are affine decision nodes. However, this language is not appealing as a target language for knowledge compilation, because it contains the language BDD of binary decision diagrams (alias branching programs) [Bryant, 1986] as a subset and BDD does not offer any query from the KC map [Darwiche and Marquis, 2002], unless P = NP. Thus, the problem of finding interesting classes of affine decision graphs that are tractable for model counting looks stimulating.

From the practical side, there are many ways to improve our compiler. Notably, it would be interesting to take advantage of preprocessing techniques [Piette et al., 2008; J¨arvisalo et al., 2012] in order to simplify the input CNF formulae before compiling them. Furthermore, it could prove useful to exploit Gaussian elimination for handling more efficiently (see e.g. [Li, 2003; Chen, 2007; Soos et al., 2009]) instances that contain subproblems corresponding to affine formulae, like those reported in [Crawford and Kearns, 1995; Canni`ere, 2006]. Finally, considering other heuristics for selecting the branching affine clauses (e.g. criteria based on the mutual information metric) could also prove valuable.