2.1 Propositional satisfiability

In propositional satisfiability, we define the domain $\{0,1\}$ , which is equivalently $\{\mathsf{false}, \mathsf{true}\}$ and a propositional variable or atom $v$ takes a value from the domain. A literal $\ell$ is either a variable $v$ (positive literal) or its negation $\neg{v}$ (negative literal). A clause $C$ is a disjunction of literals, denoted as $C = \bigvee _{i} \ell _i$ . A Boolean formula $F$ , in Conjunctive Normal Form (CNF), is a conjunction of clauses, represented as $F = \bigwedge _{j} C_j$ . We use the notation $\mathsf{Var}(F)$ to denote the set of variables within $F$ .

An assignment $\tau$ over $X$ is a function $\tau : X \rightarrow \{0,1\}$ , where $X \subseteq \mathsf{Var}(F)$ . For an atom $v \in X$ , we define $\tau (\neg{v}) = 1 - \tau (v)$ . The assignment $\tau$ over $\mathsf{Var}(F)$ is a model of $F$ if $\tau$ evaluates $F$ to be $\mathsf{true}$ . Given $X \subseteq \mathsf{Var}(F)$ and an assignment $\tau$ , we use the notation $\tau _{\downarrow X}$ to denote the projection of $\tau$ onto variable set $X \subseteq \mathsf{Var}(F)$ . Given a CNF formula $F$ (as a set of clauses) and an assignment $\tau : X \rightarrow \{0,1\}$ , where $X \subseteq \mathsf{Var}(F)$ , the unit propagation of $\tau$ on $F$ , denoted $F|_{\tau }$ , is recursively defined as follows:

$F|_{\tau } = \begin{cases} 1 & \text{if $F \equiv 1$}\\ F'|_{\tau } & \text{if $\exists C \in F$ s.t. $F' = F \setminus \{C\}$,} \text{$\ell \in C$ and $\tau (\ell ) = 1$} \\ F'|_{\tau } \cup \{C'\} & \text{if $\exists C \in F$ s.t. $F' = F \setminus \{C\}$,} \text{$\ell \in C$,} \text{$C' = C \setminus \{\ell \}$} \\&\text{ and ($\tau (\ell ) = 0$ or $\{\neg{\ell }\} \in F$)} \end{cases}$

We often consider an assignment $\tau$ as a set of literals it assigns and $\mathsf{Var}(\tau )$ denotes the set of variables assigned by $\tau$ . For two assignments $\tau _1$ and $\tau _2$ , $\tau _1$ satisfies $\tau _2$ , denoted as $\tau _1 \models \tau _2$ , if ${\tau _1}_{\downarrow \mathsf{Var}(\tau _2)} = \tau _2$ . Otherwise, $\tau _1$ does not satisfy $\tau _2$ , denoted as $\tau _1 \not \models \tau _2$ .

An XOR constraint over $\mathsf{Var}(F)$ is a Boolean “XOR” ( $\oplus$ ) applied to the variables $\mathsf{Var}(F)$ . A random XOR constraint over variables $\{x_1, \ldots, x_k\}$ is expressed as $a_1 \cdot x_1 \oplus \ldots a_k \cdot x_k \oplus b$ , where all $a_i$ and $b$ follow the Bernoulli distribution with a probability of ${1}/{2}$ . An XOR constraint $x_{i_1} \oplus \ldots x_{i_k} \oplus 1$ (or $x_{i_1} \oplus \ldots x_{i_k} \oplus 0$ resp.) is evaluated as $\mathsf{true}$ if an even (or odd resp.) number of variables from $\{x_{i_1}, \ldots, x_{i_k}\}$ are assigned to $\mathsf{true}$ .

To define minimal models of a propositional formula $F$ , we introduce an ordering operator over models. For two given models $\tau _1$ and $\tau _2$ , $\tau _1$ is considered smaller than $\tau _2$ , denoted as $\tau _1 \leq \tau _2$ , if and only if for each $x \in \mathsf{Var}(F)$ , $\tau _1(x) \leq \tau _2(x)$ . We define $\tau _1$ as strictly smaller than $\tau _2$ , denoted as $\tau _1 \lt \tau _2$ , if $\tau _1 \leq \tau _2$ and $\tau _1 \neq \tau _2$ . A model $\tau$ is a minimal model of $F$ if and only if $\tau$ is a model of $F$ and no model of $F$ is strictly smaller than $\tau$ . We use the notation $\mathsf{MinModels}(F)$ to denote minimal models of $F$ and for a set $X \subseteq \mathsf{Var}(F)$ , $\mathsf{MinModels}(F)_{\downarrow X}$ denotes the minimal models of $F$ projected onto the variable set $X$ . The minimal model counting problem seeks to determine the cardinality of $\mathsf{MinModels}(F)$ , denoted $|\mathsf{MinModels}(F)|$ .

In this paper, we sometimes represent minimal models by listing the variables assigned as $\mathsf{true}$ . For example, suppose $\mathsf{Var}(F) = \{a,b,c\}$ and under minimal model $\tau = \{a, b\}$ , $\tau (a) = \tau (b) ={\mathsf{true}}$ and $\tau (c) ={\mathsf{false}}$ . The notation $\neg{\tau }$ denotes the negation of assignment $\tau$ ; in fact, $\neg{\tau }$ is a clause or disjunction of literals (e.g., when $\tau = \{a, b\}$ , $\neg{\tau } = \neg{a} \vee \neg{b}$ ). Throughout the paper, we use the notations $\tau$ and $\sigma$ to denote an arbitrary assignment and a minimal model of $F$ , respectively. For each model $\sigma \in \mathsf{MinModels}(F)$ , each of the variables assigned to $\mathsf{true}$ is justified; more specifically, for every literal $\ell \in \sigma$ , there exists a clause $c \in F$ such that $\sigma \setminus \{\ell \} \not \models c$ . Otherwise, $\sigma \setminus \{\ell \}$ (smaller than $\sigma$ ) is a model of $F$ .

2.2 Answer set programming

An answer set program $P$ consists of a set of rules, each rule is structured as follows:

(1) \begin{align} \text{Rule $r$: }a_1 \vee \ldots a_k \leftarrow b_1, \ldots, b_m, \textsf{not } c_1, \ldots, \textsf{not } c_n \end{align}

where, $a_1, \ldots, a_k, b_1, \ldots, b_m, c_1, \ldots, c_n$ are propositional variables or atoms, and $k,m,n$ are non-negative integers. The notations $\mathsf{Rules}(P)$ and $\mathsf{atoms}(P)$ denote the rules and atoms within the program $P$ . In rule $r$ , the operator “not” denotes default negation (Clark Reference Clark1978). For each rule $r$ (Eq. (1)), we adopt the following notations: the atom set $\{a_1, \ldots, a_k\}$ constitutes the head of $r$ , denoted by $\mathsf{Head}(r)$ , the set $\{b_1, \ldots, b_m\}$ is referred to as the positive body atoms of $r$ , denoted by $\mathsf{Body}(r)^+$ , and the set $\{c_1, \ldots, c_n\}$ is referred to as the negative body atoms of $r$ , denoted by $\mathsf{Body}(r)^-$ . A rule $r$ called a constraint when $\mathsf{Head}(r) = \emptyset$ . A program $P$ is called a disjunctive logic program if $\exists r \in \mathsf{Rules}(P)$ such that $|\mathsf{Head}(r)| \geq 2$ (Ben-Eliyahu and Dechter Reference Ben-Eliyahu and Dechter1994).

In ASP, an interpretation $M$ over $\mathsf{atoms}(P)$ specifies which atoms are assigned $\mathsf{true}$ ; that is, an atom $a$ is $\mathsf{true}$ under $M$ if and only if $a \in M$ (or $\mathsf{false}$ when $a \not \in M$ resp.). An interpretation $M$ satisfies a rule $r$ , denoted by $M \models r$ , if and only if $(\mathsf{Head}(r) \cup \mathsf{Body}(r)^{-}) \cap M \neq \emptyset$ or $\mathsf{Body}(r)^{+} \setminus M \neq \emptyset$ . An interpretation $M$ is a model of $P$ , denoted by $M \models P$ , when $\forall _{r \in \mathsf{Rules}(P)} M \models r$ . The Gelfond-Lifschitz reduct of a program $P$ , with respect to an interpretation $M$ , is defined as $P^M = \{\mathsf{Head}(r) \leftarrow \mathsf{Body}(r)^+| r \in \mathsf{Rules}(P), \mathsf{Body}(r)^- \cap M = \emptyset \}$ (Gelfond and Lifschitz Reference Gelfond and Lifschitz1991). An interpretation $M$ is an answer set of $P$ if $M \models P$ and no $M^\prime \subset M$ exists such that $M^\prime \models P^M$ . We denote the answer sets of program $P$ using the notation $\mathsf{AS}(P)$ .

2.3 From minimal models to answer sets

Consider a Boolean formula, $F = \bigwedge _{i} C_i$ , where each clause is of the form: $C_i = \ell _0 \vee \ldots \ell _{k} \vee \neg{\ell _{k+1}} \vee \ldots \neg \ell _{m}$ . We can transform each clause $C_i$ into a rule $r$ of the form: $\ell _{0} \vee \ldots \vee \ell _{k} \leftarrow \ell _{k+1}, \ldots, \ell _{m}$ . Given a formula $F$ , let us denote this transformation by the notation $\mathcal{DLP}(F)$ . Each minimal model of $F$ corresponds uniquely to an answer set of $\mathcal{DLP}(F)$ .

2.4 Approximate lower bound

We denote the probability of an event $e$ using the notation $\mathsf{Pr}[e]$ . For a Boolean formula $F$ , let $c$ represents a lower bound estimate for the number of minimal models of $F$ . We assert that $c$ is a lower bound for the number of minimal models with a confidence $\delta$ , when $\mathsf{Pr}[c \leq |\mathsf{MinModels}(F)|] \geq 1 - \delta$ .

2.5 Minimal generator in Itemset mining

We define transactions over a finite set of items, denoted by $\mathcal{I}$ . A transaction $t_i$ is an ordered pair of $(i, I_i)$ , where $i$ is the unique identifier of the transaction and $I_i \subseteq{\mathcal{I}}$ represents the set of items involved in the transaction. A transaction database is a collection of transactions, where each uniquely identified by the identifier $i$ , corresponding to the transaction $t_i$ . A transaction $(i, I_i)$ supports an itemset $J \subseteq \mathcal{I}$ if $J \subseteq I_i$ . The cover of an itemset $J$ within a database $D$ , denoted as $C(J,D)$ , is defined as: ${\mathcal{C}(J,D)} = \{i | (i,I_i) \in D \text{ and } J \subseteq I_i\}$ . Given an itemset $I$ and transaction database $D$ , the itemset $I$ is a minimal generator of $D$ if, for every itemset $J$ where $J \subset I$ , it holds that ${\mathcal{C}(I,D)} \subset{\mathcal{C}(J,D)}$ .

2.6 Encoding minimal generators as minimal models

Given a transaction database $D$ , we encode a Boolean formula $\mathsf{MG}(D)$ such that minimal models of $\mathsf{MG}(D)$ correspond one-to-one with the minimal generators of $D$ . This encoding introduces two types of variables: (i) for each item $a \in{\mathcal{I}}$ , we introduce a variable $p_a$ to denote that $a$ is present in a minimal generator (ii) for each transaction $t_i$ , we introduce a variable $q_i$ to denote the presence of the itemset in the transaction $t_i$ . Given a transaction database $D = \{t_i| i = 1,\ldots n\}$ , consisting of the union of transactions $t_i$ , consider the following Boolean formula:

(2) \begin{align} \mathsf{MG}(D) = \bigwedge _{i=1}^{n} \bigg ( \neg{q_i} \rightarrow \bigvee _{a \in{\mathcal{I}} \setminus I_i} p_a \bigg ) \end{align}

The encoding of $\mathsf{MG}(D)$ bears similarities to the encoding detailed in (Jabbour et al. Reference Jabbour, Sais and Salhi2017; Salhi Reference Salhi2019). However, our encoding achieves compactness by incorporating a one-sided implication, which enhances the efficiency of the representation.

4.1 Formula decomposition and minimal model counting

Considering a Boolean formula $F = F_1 \wedge F_2$ , we define the components $F_1$ and $F_2$ as disjoint if no variable of $F$ is mentioned by both components $F_1$ and $F_2$ (i.e., $\mathsf{Var}(F_1) \cap \mathsf{Var}(F_2) = \emptyset$ ). Under this condition, the models of $F$ can be independently derived from the models of $F_1$ and $F_2$ and the vice versa. Thus, if $F_1$ and $F_2$ are disjoint in the formula $F = F_1 \wedge F_2$ , the total number of models of $F$ is the product of the number of models of $F_1$ and $F_2$ . This principle underpins the decomposition frequently applied in knowledge compilation (Lagniez and Marquis Reference Lagniez and Marquis2017).

Building on the concept of the knowledge compilation techniques, we introduce a strategy centered on formula decomposition to count minimal models. Unlike methods that count models for each disjoint component, we enumerate minimal models of $F$ projected onto the variables of disjoint components. Our approach incorporates a level of enumeration that stops upon enumerating a specific count of minimal models, thereby providing a lower bound estimate of the total number of minimal models. Our method utilizes a straightforward “Cut” mechanism to facilitate formula decomposition.

4.1.4 Algorithm: counting minimal models by projected enumeration

We introduce an enumeration-based algorithm, called $\mathsf{Proj\text{-}Enum}$ , that leverages justified assignments and projected enumeration to accurately count the number of minimal models of a Boolean formula $F$ . The algorithm takes in as input a Boolean formula $F$ and a set of variables $\mathcal{C}$ , referred to as a “cut” in our context. To understand how the algorithm works, we introduce two new concepts: $\mathsf{MinModelswithBlocking}(F, \mathcal{B})$ and $\mathsf{ProjMinModels}(F, \tau, X)$ . $\mathsf{MinModelswithBlocking}(F, \mathcal{B})$ finds $\sigma \in \mathsf{MinModels}(F)$ such that $\forall \tau \in \mathcal{B}, \sigma \not \models \tau$ ; here, $\mathcal{B}$ is a set of blocking clauses and each blocking clause is an assignment $\tau$ . $\mathsf{ProjMinModels}(F, \tau, X)$ enumerates the set $\{\sigma _{\downarrow X} | \sigma \in \mathsf{MinModels}(F), \sigma \models \tau \}$ , where $\tau$ serves as the conditioning factor and $X$ serves as the projection set. The algorithm iteratively processes minimal models of $F$ (Line 2), starting with an initially empty set of blocking clauses ( $\mathcal{B} = \emptyset$ ). Upon identifying a minimal model $\sigma$ , the algorithm projects $\sigma$ onto $\mathcal{C}$ , denoting the projected set as $\tau$ . Subsequently, Algorithm1 enumerates all minimal models $\sigma \in \mathsf{MinModels}(F)$ that satisfy $\sigma \models \tau$ .

To address the inefficiency associated with brute-force enumeration, the algorithm utilizes the concept of justified assignment and projected enumeration (Line 5). Lemma2 establishes that the number of minimal models can be counted through multiplication. The notation $\mathsf{Components}(F)$ (Line 4) denotes all disjoint components of the formula $F$ . It is important to note that if $F|_{\tau ^{\star }}$ does not decompose into more than one component, then the projection variable set $X$ defaults to $\mathsf{Var}(F)$ , which leads to brute-force enumeration of non-projected minimal models. Finally, the algorithm adds $\tau$ to $\mathcal{B}$ (Line 7) to prevent the re-enumeration of the same minimal models.

Algorithm 1.

$\mathsf{Proj\text{-}Enum}$ (F, $\mathcal{C}$ )

4.2 Hashing-based minimal model counting

The number of minimal models can be approximated using a hashing-based model counting technique, which adds constraints that restrict the search space. Specifically, this method applies uniform and random XOR constraints to a formula $F$ , focusing the search on a smaller subspace (Gomes et al. Reference Gomes, Sabharwal and Selman2021). A particular XOR-based model counter demonstrates that if $t$ trials are conducted where $s$ random and uniform XOR constraints are added each time, and the constrained formula of $F$ is satisfiable in all $t$ cases, then $F$ has at least $2^{s - \alpha }$ models with high confidence, where $\alpha$ is the precision slack (Gomes et al. Reference Gomes, Sabharwal and Selman2006a). Each XOR constraint incorporates variables from $\mathsf{Var}(F)$ . Our approach to minimal model counting fundamentally derives from the strategy of introducing random and uniform XOR constraints to the formula. In the domain of approximate model counting and sampling, the XOR constraints consist of variables from a subset of $\mathsf{Var}(F)$ , denoted as $\mathcal{X}$ within our algorithm, which is widely known as independent support (Chakraborty et al. Reference Chakraborty, Meel and Vardi2016; Soos and Meel Reference Soos and Meel2022).

Algorithm2 outlines a hashing-based algorithm, named $\mathsf{HashCount}$ , for determining the lower bound of minimal models of a Boolean formula $F$ . This algorithm takes in a Boolean formula $F$ , an independent support $\mathcal{X}$ , and a confidence parameter $\delta$ . During its execution, the algorithm generates total $|{\mathcal{X}}| - 1$ random and uniform XOR constraints, denoted as $Q^i$ , where $i$ ranges from $1$ to $|{\mathcal{X}}| - 1$ . To better explain the operation of the algorithm, we introduce a notation: $\mathsf{MinModels}(F^m)$ represents the minimal models of $F$ satisfying first $m$ XOR constraints, $Q^1, \ldots, Q^m$ . Upon generating random and uniform XOR constraints, the algorithm finds the value of $m$ such that $|\mathsf{MinModels}(F^{m})| \gt 0$ (meaning that $\exists \sigma \in \mathsf{MinModels}(F), \sigma \models Q^1 \wedge \ldots \wedge Q^m$ ), while $|\mathsf{MinModels}(F^{m+1})| = 0$ (meaning that $\not \exists \sigma \in \mathsf{MinModels}(F), \sigma \models Q^1 \wedge \ldots \wedge Q^{m+1}$ ) by iterating a loop (Line 6). The loop terminates either when a $\mathsf{Timeout}$ occurs or when it successfully identifies the value of $m$ . If the $\mathsf{Timeout}$ happens, the algorithm assigns the maximum observed value of $m$ (denoted as $\mathsf{\hat{m}}$ ) to $\mathsf{m^{\star }}$ , ensuring that $|\mathsf{MinModels}(F^{\mathsf{\hat{m}}})| \geq 1$ (Line 7), which is sufficient to offer lower bounds. Finally, Algorithm2 returns $2^{\mathsf{m^{\star }} - \alpha }$ as the probabilistic lower bound of $|\mathsf{MinModels}(F)|$ .

Algorithm 2.

$\mathsf{HashCount}(F,{\mathcal{X}}, \delta )$

4.3 Putting it all together

Algorithm 3.

$\mathsf{MinLB}(F, \delta$ )

We designed a hybrid solver $\mathsf{MinLB}$ , presented in Algorithm3, that selects either $\mathsf{Proj\text{-}Enum}$ or $\mathsf{HashCount}$ depending on the decomposability of the input formula. The core principle of $\mathsf{MinLB}$ is that $\mathsf{Proj\text{-}Enum}$ effectively leverages decomposition and projected enumeration on easily decomposable formulas. We use the size of the cut ( $|{\mathsf{Cut}(F)}|$ ) as a proxy to measure the decomposability. Thus, if $|{\mathsf{Cut}(F)}|$ is small, then $\mathsf{MinLB}$ employs $\mathsf{Proj\text{-}Enum}$ on $F$ (Line 2); otherwise, it employs $\mathsf{HashCount}$ (Line 3).

5.1 Benchmarks and baselines

Our benchmark set is collected from two different domains: (i) model counting benchmarks from recent competitions (Fichte et al. Reference Fichte, Hecher and Hamiti2021) and (ii) minimal generators benchmark from itemset mining dataset CP4IM.Footnote ² We used existing systems for minimal model reasoning as baselines. These included various approaches such as (i) repeated invocations of the SAT solver MiniSAT (Li et al. Reference Li, Yisong, Zhongtao and Renyan2021), (ii) the application of MaxSAT techniques (Alviano Reference Alviano2017), (iii) domain-specific heuristics (Gebser et al. Reference Gebser, Kaufmann and Schaub2013), and (iv) solving $\mathcal{DLP}(F)$ with ASP solvers, all systems primarily count via enumeration. These systems either return the number of minimal models by enumerating all of them or a lower bound of the number of minimal models in cases where they run out of time or memory. We cannot count minimal models by #SAT-based ASP counters (Kabir et al. Reference Kabir, Chakraborty and Meel2024) because of their incapablity of handling disjunctive logic programs. Experimentally, we observed that, for enumerating all minimal models, the technique solving disjunctive ASP programs using clingo (Gebser et al. Reference Gebser, Kaufmann and Schaub2012) surpassed the other techniques. Therefore, we have exclusively reported the performance of clingo in our experimental analysis. Additionally, we evaluated ApproxASP (Kabir et al. Reference Kabir, Everado, Shukla, Hecher, Fichte and Meel2022), which offers $(\epsilon, \delta )$ -guarantees in counting minimal models. We attempted an exact minimal model counting tool using a subtractive approach — subtracting the non-minimal model count from the total model count–we denote the implementation using the notation $\#\mathsf{MinModels}$ in further analysis. In our experiment, we ran $\mathsf{HashCount}$ with a confidence $\delta$ value of $0.2$ and ApproxASP with confidence $\delta = 0.2$ and tolerance $\epsilon = 0.8$ . The prototype is available at: https://github.com/meelgroup/MinLB.

5.2 Environmental settings

All experiments were conducted on a high-performance computing cluster equipped with nodes featuring AMD EPYC $7713$ CPUs, each with $128$ real cores. Throughout the experiment, the runtime and memory limits were set to $5000$ seconds and $16$ GB, respectively, for all considered tools.

5.3 Evaluation metric

The goal of our experimental analysis is to evaluate various minimal model counting tools based on their runtime and the quality of their lower bounds. It is essential to employ a metric that encompasses both runtime performance and the quality of the lower bound. Consequently, following the TAP score (Agrawal et al. Reference Agrawal, Pote and Meel2021; Kabir and Meel Reference Kabir and Meel2023), we have introduced a metric, called the Time Quality Penalty (TQP) score, which is defined for each tool and instance as follows:

\begin{equation*} \mathsf {TQP}(t, C) = \begin {cases} 2 \times {\mathcal {T}}, & \text {if no lower bound is returned} \\ t + {\mathcal {T}} \times \frac {1 + \log {(\mathsf {C_{min}} + 1)}}{1 + \log {(C+1)}}, & \text {otherwise } \\ \end {cases} \end{equation*}

In the metric, $\mathcal{T}$ represents the timeout for the experiment, $t$ denotes the runtime of the tool, $C$ is the lower bound returned by the tool, and $\mathsf{C_{min}}$ is the minimum lower bound returned by any of the tools under consideration for the instance. The TQP score is based on the following principle: lower runtime and higher lower bound yield a better score.

Table 1.

The Time Quality Penalty scores of $\mathsf{MinLB}$ and other tools on model counting benchmark

Fig 1.

The lower bound of $\mathsf{Proj\text{-}Enum}$ and $\mathsf{HashCount}$ vis-a-vis the lower bound returned by clingo on minimal model counting benchmark. The axes are in log scale.

5.4 Performance on model counting competition benchmark

We present the TQP scores of $\mathsf{MinLB}$ alongside other tools in Table 1. This table indicates that $\mathsf{MinLB}$ achieves the lowest TQP scores. Among existing minimal model enumerators, clingo demonstrates the best performance in terms of TQP score. Additionally, in Figure 1, we graphically compare the lower bounds returned by $\mathsf{Proj\text{-}Enum}$ and $\mathsf{HashCount}$ against those returned by $clingo$ . Here, a point $(x, y)$ indicates that, for an instance, the lower bounds returned by our prototypes and clingo are $2^x$ and $2^y$ , respectively. For an instance, if the corresponding point resides below the diagonal line, it indicates that $\mathsf{Proj\text{-}Enum}$ ( $\mathsf{HashCount}$ , resp.) returns a better lower bound than $clingo$ . These plots clearly illustrate that $\mathsf{Proj\text{-}Enum}$ and $\mathsf{HashCount}$ return better lower bounds compared to other existing minimal model enumerators.

5.5 Performance on minimal generator benchmark

Table 2 showcases the TQP scores of $\mathsf{MinLB}$ alongside other tools on the minimal generator benchmark. Notably, $\mathsf{HashCount}$ achieves the most favorable TQP scores on the benchmark. Additionally, Figure 2 graphically compares the lower bounds returned by $\mathsf{Proj\text{-}Enum}$ and $\mathsf{HashCount}$ against those computed by $clingo$ .

For a visual representation of the lower bounds returned by our $\mathsf{HashCount}$ and $\mathsf{Proj\text{-}Enum}$ , we illustrate them graphically in Figure 3. In the plot, a point $(x, y)$ signifies that a tool returns a lower bound of at most $2^y$ for $x$ instances. The plot demonstrates that the lower bounds returned by $\mathsf{Proj\text{-}Enum}$ and $\mathsf{HashCount}$ surpass those of existing systems.

Table 2.

The Time Quality Penalty scores of $\mathsf{MinLB}$ and other tools on minimal generator benchmark

Fig 2.

The lower bound returned by $\mathsf{Proj\text{-}Enum}$ and $\mathsf{HashCount}$ vis-a-vis the lower bound given by clingo on minimal generators benchmark. The axes are in log scale.

Fig 3.

The lower bounds returned by $\mathsf{Proj\text{-}Enum}$ , $\mathsf{HashCount}$ , and existing minimal model counting tools. The $y$ -axis show the log of the number of models.

5.6 Another performance metric

To facilitate the comparison of lower bounds returned by two tools, we have introduced another metric for comparative analysis. If tools $A$ and $B$ yield lower bounds $C_A$ and $C_B$ respectively, their relative quality is defined in the following manner:

(3) \begin{align} r_{AB} = \frac{1 + \log{(C_A + 1)}}{1 + \log{(C_B + 1)}} \end{align}

If $r_{AB} \gt 1$ , then the lower bound returned by tool $A$ is superior to that of tool $B$ .

5.6.1 In-depth study on $\mathsf{Proj\text{-}Enum}$ and $\mathsf{HashCount}$

The performance of $\mathsf{Proj\text{-}Enum}$ and $\mathsf{HashCount}$ contingent upon the size of the cut and independent support, respectively. In this analysis, we explore the strengths and weaknesses of $\mathsf{Proj\text{-}Enum}$ and $\mathsf{HashCount}$ by measuring their relative quality, as defined in Equation (3), across various sizes of cuts and independent supports, respectively. This comparative analysis is visually represented in Figure 4, where clingo serves as the reference baseline.

In the graphical representations, each point $(x,y)$ corresponds to an instance where for the size of cut (independent support resp.) is $x$ and the prototype $\mathsf{Proj\text{-}Enum}$ ( $\mathsf{HashCount}$ resp.) achieves a relative quality of $y$ . A relative quality exceeding $1$ indicates that the lower bound returned by $\mathsf{Proj\text{-}Enum}$ or $\mathsf{HashCount}$ surpasses that of clingo. These plots reveal that $\mathsf{Proj\text{-}Enum}$ tends to perform well with smaller cut sizes, while $\mathsf{HashCount}$ demonstrates better performance across a range from small to medium sizes of independent support.

Fig 4.

The relative quality of $\mathsf{Proj\text{-}Enum}$ and $\mathsf{HashCount}$ vis-a-vis different cut and independent support size, where clingo is used as the reference baseline. The horizontal line is across $r = 1$ .