A Deletion Algorithm for the Marginal Problem in Propositional Logic Based on Boolean Arrays

Abstract

This paper proposes a deletion algorithm for the marginal problem in propositional logic. The algorithm is based on the general Davis and Putnam deletion algorithm DP, expressed as a bucket elimination algorithm, representing sets of clauses with the same set of variables employing a Boolean array. The main contribution is the development of alternative procedures when deleting a variable which allow more efficient computations. In particular, it takes advantage of the case in which the variable to delete is determined by a subset of the rest of the variables. It also provides a set of useful results and tools for reasoning with Boolean tables. The algorithms are implemented using Python and the NumPy library. Experiments show that this procedure is feasible for intermediate problems and for difficult problems from hard Bayesian networks cases

1. Introduction

The marginal problem consists of computing the consequences of a set of propositional formulae in a reduced subset of variables. The basic algorithm to solve it has been the so-called Davis and Putnam (DP) [1] deletion algorithm. This algorithm is a particular case of the Shenoy–Shafer deletion algorithm [2,3] or the bucket elimination scheme [4,5]. The problem of this algorithm is the space complexity (it tends to produce too many clauses of large size). The time complexity is exponential in the tree-width of its connectivity graph [4]. The computations can be organized in a join tree [6] in the same way as probabilistic computations in Bayesian networks [2,7]. However, in the case of propositional logic, we are in a case of computation in an idempotent valuation system or valuation algebra [3,8], which has some special features which can be exploited in order to build efficient algorithms.

This paper proposes new algorithms for the marginal problem by applying the Shenoy–Shafer abstract framework [2], but it has some differences compared to the DP algorithm. First, it represents sets of clauses as Boolean arrays. This is a semantic representation of the set of true assignments satisfying a given set of clauses, i.e., a truth table. Boolean arrays can be a very efficient representation of a large set of clauses, as the values on the array are simple 0–1 values, though its size is exponential in the number of variables. We define the basic operations and show that the set of Boolean arrays with these operations has the structure of an information algebra [3]. Secondly, we also give alternative deletion procedures and a set of possible optimizations of the full procedure. In this sense, a very important contribution is the study of the cases in which a variable is functionally determined by a set of variables and the exploitation of this fact in the marginalization algorithms. The Boolean array representation is especially appropriate for this improvement.

The final result is a family of tools and algorithms that can solve moderate-sized problems, even in cases where the associated connectivity graph has a large tree width (more than 100), as is shown in the experiments.

A related problem is the satisfiability problem (SAT) [9], which consists of determining if a set of propositional formulae is satisfiable, i.e., there is a true assignment such that every formula becomes true. It is the first problem proven to be NP-complete [10]. This implies that any NP problem can be efficiently reduced to it, and therefore, any good algorithm to solve the SAT could also be used for such an NP problem. In fact, many well-known problems are solved nowadays by encoding them as an SAT  [11,12,13]. Current approaches for SATs are mainly based on the Davis–Putnam–Logemann–Loveland backtracking algorithm (DPLL) [14], and its successors, conflict-driven clause-learning algorithms (CDCL) [15]. The SAT problem can be solved from the marginal problem, by deleting all the variables (marginalizing over the empty set). The result is consistent if and only if this marginalization is vacuous. However, the marginal problem can be used without deleting all the variables for computing the marginal in a given set and it can be used to compute all the solutions (configurations satisfying all the clauses) or to simulate in the space of solutions, in the case of a satisfiable problem [6]. As is said in [5], the marginal problem is a kind of knowledge compilation that can be useful in many other related problems. Furthermore, in a recent survey of SAT-related problems [16], the following was noted: “We see that DP responds to a more difficult problem than the simple problem of satisfiability. Except for a few specific problems of small induced width, DP-60 never really competed with the version of DP-62” (where DP-60 is what we have called DP and DP-62 makes reference to DPLL). For this reason, the basic deletion algorithm has received little attention in the literature. For example, in Knuth’s book [17], covering the existing approaches for SAT, there is only a short reference to the DP approach, saying that it works well for small problems, but that it can be very inefficient in the worst case. Our paper will show that it is possible to solve large problems, even problems with a large tree width. The initial DP algorithm was revisited in  [4,5], but this approach was also based on a clause representation and the main contributions were the determination of good deletion sequences.

Another related problem is propositional model counting or #-SAT, consisting of computing the number of models satisfying a given formula [18]. This is related to probabilistic computations and it is known to be #P-complete. Similar deletion algorithms have been applied; however, as is said in Gogate and Dechter [19], these algorithms are exponential with the tree-width size. In this paper, we take advantage of using idempotent valuations and develop a computation method that can solve some concrete cases, even if the tree width is large, using representations that are not exponential with such a tree width.

We provide some experiments carried out with our Python 3.8.8 implementation based on the NumPy library for representing arrays (the library together with data to reproduce experiments are available as a Github repository at: https://github.com/serafinmoral/SAT-solver (accessed on 16 May 2023)). In them, we show that it is possible to solve some moderate-sized problems, expanding the class of problems solved by the existing deletion algorithms. The contribution is also significant because of the possibilities it opens for future developments, as proposed in the last section of the paper devoted to the conclusions and future work. We have also shown that it is possible to solve the 0–1 problems associated with hard Bayesian networks inference problems. The rest of the paper is organized as follows: in Section 2, the notation and the problem specification are given; Section 3 is devoted to the table representation of sets of clauses, the introduction of the basic operations (combination, marginalization, and conditioning), and the study of their properties; Section 4 studies the basic deletion algorithm and the alternative procedures, providing formal results of their main properties; in Section 5, a set of additional tools for the deletion algorithm are given, and the final decision procedure for the deletion algorithm is described; Section 6 is devoted to the experimental part; and Section 7 details the conclusions and future work. All the proofs of the results in the paper are in Appendix A.

2. Problem Specification

Let $V=\{p,q,r,s,\dots \}$ a finite set of variables or propositional symbols. A literal is either a variable, p, (positive literal) or a negated variable $\neg p$ (negative literal). A clause c is a disjunction of literals, $p\vee \neg r\vee s$, which we will represent as a set $c=\{p,\neg r,s\}$. If a clause contains literals p and $\neg p$, then it will be called trivial or tautology. The set of all non-trivial clauses defined for variables V is denoted as $\mathcal{L}\left(V\right)$.

Information will be given as a finite set of non-trivial clauses C. The set of variables appearing in clause c will be denoted by $V\left(c\right)$. If C is a set of clauses, then $V\left(C\right)={\bigcup }_{c\in C}V\left(c\right)$.

A true assignment, t, is a mapping from V to $\{False,True\}$. A true assignment t satisfies the set of clauses C when for each $c\in C$, there is a positive literal, $p\in c$, with $t\left(p\right)=True$ or a negative literal, $\neg r\in c$, with $t\left(r\right)=False$.

Two sets of clauses, $C_1$ and $C_2$, defined for the same set of variables V, will be considered logically equivalent, $C_1\equiv C_2$, when for each true assignment t, we have that t satisfies $C_1$ if and only if t satisfies $C_2$.

The basic syntactic operation with clauses is resolution: given two clauses $c_1$ and $c_2$ such that there is a variable r such that $r\in c_1$ and $\neg r\in c_2$, then the resolution of $c_1$ and $c_2$ by r is the clause $R(c_1,c_2,r)=(c_1\backslash \left\{r\right\})\cup (c_2\backslash \{\neg r\})$. A set of clauses C is said to be complete under set of variables V if and only if for each $c_1,c_2\in C$, if $R(c_1,c_2,r)$ is not trivial, then $R(c_1,c_2,r)\in C$ and if $c\in C$ and $c\subseteq c^{\prime }\in \mathcal{L}\left(V\right)$ (i.e., $c^{\prime }$ is subsumend by c), and then $c^{\prime }\in C$. Given a set of clauses, C, there is always a minimum set of clauses (in the sense of inclusion) which contains C and is complete (the set obtained by adding to C all the clauses obtained by resolution and subsumption). It will be denoted by $\mathcal{C}\left(C\right)$. It is clear that two sets of clauses, $C_1$ and $C_2$, defined for the same set of variables V, are equivalent if and only if $\mathcal{C}\left(C_1\right)=\mathcal{C}\left(C_2\right)$

A set of clauses C implies clause c if and only if $c\in \mathcal{C}\left(C\right)$ and this is denoted as $C⊢c$. It is well known that this is equivalent to the fact that any true assignment t satisfying C also satisfies c. If $C_1$ and $C_2$ are two sets of clauses and for each $c\in C_2$ we have that $C_1⊢c$, it can be said that $C_1$ implies $C_2$, which is denoted by $C_1⊢C_2$. This is equivalent to the fact that any satisfying true assignment for $C_1$ is also a true assignment for $C_2$. It is also well known that $C_1$ and $C_2$ are equivalent if and only if $C_1⊢C_2$ and $C_2⊢C_1$.

The satisfiability problem (SAT) consists of determining if for a given set of clauses C there is a satisfying true assignment t for it. It is clear that if C is empty, then the answer is positive, and if the empty clause belongs to C, the answer is negative. This is an NP-complete problem [10], and therefore, hard to solve.

The algorithms in this paper will be based on the Davis–Putnam deletion algorithm  [1]. The basic step of this algorithm is the deletion of a variable in a set of clauses C, denoted as $C^{-v}$. This operation is carried out with the following steps:

(1)

Compute $C_v^{+}=\{c\in C:vs.\in c\}$

$C_v^{-}=\{c\in C|\neg vs.\in c\}$

$C_v^0=C\backslash (C_v^{+}\cup C_v^{-})$

(2)

The result is

$C^{-v}=\{R(c,c^{\prime },v):c\in C_v^{+},c^{\prime }\in C_v^{-},R(c,c^{\prime },v) \mathrm{non} \mathrm{trivial}\}\cup C_v^0$.

An algorithm for SAT based on the deletion of variables is depicted in Algorithm 1. At the end of the loop, as all the variables have been deleted, one of the two conditions ($C=\varnothing$ or $\varnothing \in C$) must be satisfied. Its efficiency depends of the order of removing variables; however, in general, this algorithm has the problem of producing too many clauses that are large in size (number of literals).

It is also advisable to make some basic operations on C so that a simpler equivalent set is obtained. For example, it is always good to remove subsumed clauses, i.e., if $c,c^{\prime }\in C$ and $c⊊c^{\prime }$, then remove $c^{\prime }$ from C. Unit propagation is another important step. For that, we need the concept of restriction of a set of clauses C to a literal ℓ, which is the set of clauses that is equivalent to C under the condition that ℓ is true. It will be denoted as $U(C,\mathcal{l})$ and it is the set of clauses obtained from C by removing any clause containing ℓ and removing $\neg \mathcal{l}$ from the clauses containing $\neg \mathcal{l}$. It is important to remark that the true assignments satisfying $U(C,\mathcal{l})$ are the same as those satisfying C with ℓ set to $True$.

Algorithm 1 David-Putnam deletion algorithm

Require:  C, a set of clauses. Ensure:  $sat$, a logical value indicating whether C is satisfiable.   1: procedure DP(C)   2:     $V\leftarrow$ variables of C   3:     for  $v\in V$ do   4:           $C\leftarrow C^{-v}$   5:           if  $C=\varnothing$ then   6:               $sat\leftarrow True$   7:               Break   8:           end if   9:           if  $\varnothing \in C$ then   10:              $sat\leftarrow False$   11:              Break   12:          end if   13:     end for   14:     return $sat$   15: end procedure

Unit propagation consists of transforming C containing a unit clause with a single literal $\left\{\mathcal{l}\right\}\in C$, into $U(C,\mathcal{l})\cup \left\{\right\{\mathcal{l}\left\}\right\}$. This operation is repeated for each literal ℓ appearing in a unit clause $c=\left\{\mathcal{l}\right\}\in C$.

If C is a set of clauses defined for variables V and $V^{\prime }$ is a subset of V, then the marginalization of C to $V^{\prime }$ is the set of clauses $\mathcal{C}\left(C\right)\cap \mathcal{L}\left(V^{\prime }\right)$, i.e., the set of all the clauses that are defined for variables in $V^{\prime }$ and are a consequence of the clauses in C. The marginalization to $V^{\prime }$ will be denoted as $C^{-V\backslash V^{\prime }}$ making reference to the set of removed variables. The David and Putnam algorithm has two main advantages against other satisfiability algorithms [5,6]. The first one is that the deletion algorithm is really an algorithm to compute the marginal information and has many other utilities. Then, if the loop starting in step 3 of the algorithm is applied for variables $v\in V^{\prime }$, then the value of C will be equivalent to $C^{-V^{\prime }}$. This is a consequence of the fact that each step carries out a deletion of a variable $v\in V^{\prime }$ and that the set of clauses is a particular case of the Shenoy–Shafer axiomatic framework for local computation [2,6].

3. Table Representation of Sets of Clauses

A set of clauses C defined for variables V can be represented by a table with a dimension for each variable $v\in V$. If $v\in V$, we consider the set ${\mathsf{\Omega }}_v=\{\neg v,v\}$ and ${\mathsf{\Omega }}_V={\prod }_{v\in V}{\mathsf{\Omega }}_v$, where ∏ stands for Cartesian product. An element from ${\mathsf{\Omega }}_V$ will be denoted in boldface $\mathbf{v}$. The component v of vector $\mathbf{v}$ will be denoted as ${\mathbf{v}}_v$. If $V^{\prime }\subseteq V$, the subvector of $V^{\prime }$ components will be denoted by ${\mathbf{v}}^{-V\backslash V^{\prime }}$, making reference to the removed components.

A table T for variables V will be a mapping $T:{\mathsf{\Omega }}_V\to \{0,1\}$. The set of variables of table T will be denoted by $V\left(T\right)$. A table T needs $2^{\left|V\right(T\left)\right|}$ bits to be represented.

To simplify the notation, if a table T is defined for variables V and being $V\subseteq V^{\prime },{\mathbf{v}}^{\prime }\in {\mathsf{\Omega }}_{V^{\prime }}$, we will assume that $T\left({\mathbf{v}}^{\prime }\right)=T\left({\mathbf{v}}^{\prime -V^{\prime }\backslash V}\right)$, i.e., a table can be applied to a larger frame than the actual frame in which it is defined, simply by ignoring the components not in the set of variables for which it is defined.

The set of all tables defined for variables V will be denoted as ${\mathcal{T}}_V$.

A set of clauses C is represented by a table T if $T\left(\mathbf{v}\right)=1$ if and only if the true assignment given by $t_{\mathbf{v}}\left(v\right)=True$ when ${\mathbf{v}}_v=v$ and $t_{\mathbf{v}}\left(v\right)=False$ when ${\mathbf{v}}_v=\neg v$ satisfies C. This is a semantic representation of the set of clauses C by determining the true assignments satisfying all the clauses, i.e., a truth table.

To simplify the notation, we will consider that vector $\mathbf{v}$ and $t_{\mathbf{v}}$ are equivalent, so that $\mathbf{v}$ can also be called a true assignment, but in fact making reference to $t_{\mathbf{v}}$. Then, in the tables, a true assignment will be a vector $\mathbf{v}$, and this true assignment satisfies table T when $T\left(\mathbf{v}\right)=1$. The set of true assignments satisfying a table T will be $\mathbf{T}\left(T\right)=\{\mathbf{v}\in {\mathsf{\Omega }}_{V\left(T\right)}:T\left(\mathbf{v}\right)=1\}$.

The trivial table is the table $T_e$ with $T_e\left(\mathbf{v}\right)=1$ for any $\mathbf{v}\in {\mathsf{\Omega }}_V$ and the contradictory table $T_0$ is the table with $T_0\left(\mathbf{v}\right)=0$ for any $\mathbf{v}\in {\mathsf{\Omega }}_V$. A trivial table represents the empty set of clauses and a contradictory table; an unsatisfiable set of clauses.

Given C, a table T can be easily computed starting with a trivial table, and then for each $c\in C$, we make $T\left(\mathbf{v}\right)=0$ for each $\mathbf{v}$, such that for each literal $\mathcal{l}\in c$ associated with variable v, we have that ${\mathbf{v}}_v\ne \mathcal{l}$, i.e., ${\mathbf{v}}_v=v$ if $\mathcal{l}=\neg v$ and ${\mathbf{v}}_v=\neg v$ if $\mathcal{l}=v$.

Given a set of clauses C defined for variables V, the direct table representation is unfeasible if the number of variables of V is not small, given that the table size is $2^{\left|V\right|}$, where $\left|V\right|$ is the cardinal of V. For this reason, to represent a set of clauses C, first, we will partition the full set of clauses in small sets, $C_1,\dots ,C_k$, each one of them defined for a small set of variables $V_1,\dots ,V_k$. Then, the set C will be represented by the set of tables $T_1,\dots ,T_k$, where $T_i$ is the table representing $C_i$.

In our experiments, the partition has been computed by the following steps:

• Carry out unit propagation in C;
• Group together clauses defined for the same set of variables, i.e., if $V\left(c\right)=V\left(c^{\prime }\right)$, then $c,c^{\prime }\in C_i$;
• Remove sets defined for non-maximal sets of variables, i.e., if $C_i$ is such that there is another set of variables $C_j$ such that $V\left(C_i\right)\subset V\left(C_j\right)$, then $C_j$ is updated to $C_i\cup C_j$ and $C_i$ is removed.

This is a procedure that we have found reasonable, but it is not the only possible one. We find that steps 1 and 2 are basic, but that there can be other alternative ways of performing step 3. For example, joining into a set, $C_i$ and $C_j$, if $|C_i\cap C_j|$ is not small and $|C_i\cup C_j|$ is not too large, where large and small can be defined in terms of a couple of parameters $n_1,n_2$ in each case.

There are three basic operations with tables:

• Combination. If $T_1$ and $T_2$ are tables, then its combination is the table $T_1\otimes T_2$ defined for set of variables $V=V\left(T_1\right)\cup V\left(T_2\right)$ and given by:

  $$(T_1\otimes T_2)\left(\mathbf{v}\right)=min\{T_1\left(\mathbf{v}\right),T_2\left(\mathbf{v}\right)\}.$$
  When considering $T_1\left(\mathbf{v}\right)$, it is important to notice that this value is $T_1\left({\mathbf{v}}^{V\backslash V\left(T_2\right)}\right)$.
• Variable deletion. If T is a table and $V^{\prime }\subseteq V\left(T\right)$, then table $T^{-V^{\prime }}$ is the table defined for variables $V^{\prime }$ and given by:

  $$T^{-V^{\prime }}\left({\mathbf{v}}^{\prime }\right)=max\{T\left(\mathbf{v}\right):\mathbf{v}\in {\mathsf{\Omega }}_V,{\mathbf{v}}^{-V^{\prime }}={\mathbf{v}}^{\prime }\}.$$
  $T^{-V^{\prime }}$ will also be called the marginalization of T to $V\left(T\right)\backslash V^{\prime }$. If $V^{\prime }=\left\{v\right\}$, then $T^{-V^{\prime }}$ will also be denoted as $T^{-v}$.
• Conditioning. If T is a table and ℓ is a literal associated with $v\in V\left(T\right)$, then the conditioning of T to ℓ is the table $U(T,\mathcal{l})$ defined for variables $V^{\prime }=V\left(T\right)\backslash \left\{v\right\}$ and given by:

  $$U(T,\mathcal{l})\left({\mathbf{v}}^{\prime }\right)=T({\mathbf{v}}^{\prime },\mathcal{l}),$$
  The conditioning operator can be extended to a partial true assignment: if T is a table, $V^{\prime }\subseteq V\left(T\right)$ and ${\mathbf{v}}^{\prime }$ is a true assignment for variables $V^{\prime }$, then $U(T,{\mathbf{v}}^{\prime })$ is the table defined for variables $V^{″}=V\left(T\right)\backslash V^{\prime }$ and given by:

  $$U(T,{\mathbf{v}}^{\prime })\left({\mathbf{v}}^{″}\right)=T({\mathbf{v}}^{″},{\mathbf{v}}^{\prime }),$$

  where $\mathbf{v}=({\mathbf{v}}^{″},{\mathbf{v}}^{\prime })$ is the vector in ${\mathsf{\Omega }}_V$ with ${\mathbf{v}}^{-V^{\prime }}={\mathbf{v}}^{″}$ and ${\mathbf{v}}^{-V^{″}}={\mathbf{v}}^{\prime }$.
  We will assume that conditioning can be applied even if the variable v associated with ℓ is not in $V\left(T\right)$. In this case, $U(T,\mathcal{l})=T$. Analogously, if $V^{\prime }$ is not included in $T\left(V\right)$ and ${\mathbf{v}}^{\prime }\in {\mathsf{\Omega }}_{V^{\prime }}$, we consider that $U(T,{\mathbf{v}}^{\prime })=U(T,{\mathbf{v}}^{\prime -V^{\prime }\backslash V\left(T\right)}).$

The following facts are immediate:

• If $T_1$ and $T_2$ are two tables associated with $C_1$ and $C_2$, respectively, then $T_1\otimes T_2$ is associated with $C_1\cup C_2$.
• If table T is associated with C, then $T^{-V^{\prime }}$ is associated with $C^{-V^{\prime }}$ and $U(T,\mathcal{l})$ is associated with $U(C,\mathcal{l})$.

We will now give an example, comparing the computations with clauses and tables.

Example 1.

Assume that we have a set C of clauses given by:

$$\{p,q,\neg r\},\{p,\neg q,r\},\{\neg p,q,r\},\{q,r,\neg s\},\{q,\neg r,s\},\{\neg q,r,s\}$$

Assume that we want to delete variable q. Then, we have to compute all the resolutions of clauses containing q with clauses containing $\neg q$. After eliminating trivial clauses, the result is given by set of clauses $C^{-q}$:

$$\{p,r,\neg s\},\{\neg p,r,s\}$$

Using a table representation, we can build a table $T_1$ for the first three clauses and a table $T_2$ for the last three ones with the following values:

$$\begin{array}{|cc|}\hline (p,q,r)& 1\\ (p,q,\neg r)& 0\\ (p,\neg q,r)& 0\\ (p,\neg q,\neg r)& 1\\ (\neg p,q,r)& 0\\ (\neg p,q,\neg r)& 1\\ (\neg p,\neg q,r)& 1\\ (\neg p,\neg q,\neg r)& 1\\ \hline\end{array},\begin{array}{|cc|}\hline (q,r,s)& 1\\ (q,r,\neg s)& 0\\ (q,\neg r,s)& 0\\ (q,\neg r,\neg s)& 1\\ (\neg q,r,s)& 0\\ (\neg q,r,\neg s)& 1\\ (\neg q,\neg r,s)& 1\\ (\neg q,\neg r,\neg s)& 1\\ \hline\end{array}$$

The combination $T_1\otimes T_2$ will be the table defined for variables $\{p,q,r,s\}$ and given by:

$$\begin{array}{|cc|}\hline (p,q,r,s)& 1\\ (p,q,r,\neg s)& 0\\ (p,q,\neg r,s)& 0\\ (p,q,\neg r,\neg s)& 0\\ (p,\neg q,r,s)& 0\\ (p,\neg q,r,\neg s)& 0\\ (p,\neg q,\neg r,s)& 1\\ (p,\neg q,\neg r,\neg s)& 1\\ (\neg p,q,r,s)& 0\\ (\neg p,q,r,\neg s)& 0\\ (\neg p,q,\neg r,s)& 0\\ (\neg p,q,\neg r,\neg s)& 1\\ (\neg p,\neg q,r,s)& 0\\ (\neg p,\neg q,r,\neg s)& 1\\ (\neg p,\neg q,\neg r,s)& 1\\ (\neg p,\neg q,\neg r,\neg s)& 1\\ \hline\end{array}$$

If in this combination, variable q is deleted by marginalization, table ${(T_1\otimes T_2)}^{-q}$ is obtained:

$$\begin{array}{|cc|}\hline (p,r,s)& 1\\ (p,r,\neg s)& 0\\ (p,\neg r,s)& 1\\ (p,\neg r,\neg s)& 1\\ (\neg p,r,s)& 0\\ (\neg p,r,\neg s)& 1\\ (\neg p,\neg r,s)& 1\\ (\neg p,\neg r,\neg s)& 1\\ \hline\end{array}$$

which is exactly the table associated with the two clauses in $C^{-q}$.

The following properties show that tables satisfy the basic Shenoy–Shafer axioms, and therefore, local computation is possible:

• Combination is commutative and associate: $T_1\otimes T_2=T_2\otimes T_1$, $T_1\otimes (T_2\otimes T_3)=(T_1\otimes T_2)\otimes T_3$;
• If $V\left(T\right)=V$ and $V_1,V_2$ are two disjoint subsets of V, then $V^{-(V_1\cup V_2)}={\left(V^{-V_1}\right)}^{-V_2}$;
• If $V\left(T_1\right)=V_1$ and $V\left(T_2\right)=V_2$, then ${(V_1\otimes V_2)}^{-V_2\backslash V_1}=V_1\otimes V_2^{-V_2\backslash V_1}$.

The tables also satisfy the idempotent property: if T is a table and $V^{\prime }\subseteq V\left(T\right)$, then $T\otimes T^{-V^{\prime }}=T$. As a consequence of these properties, if we consider a set of variables V and $\mathcal{T}={\bigcup }_{V^{\prime }\subseteq V}{\mathcal{T}}_{V^{\prime }}$, $\mathcal{T}$ is said to be information algebra [3,8]. It also has a neutral element, $T_e$, and a null element, $T_0$.

In information algebra, it is always possible to define a partial order, which in this case is the following: if $T_1$ and $T_2$ are tables defined for sets of variables $V_1$ and $V_2$, respectively, then we say that $T_1⪯T_2$ if and only if for each $\mathbf{v}\in {\mathsf{\Omega }}_{V_1\cup V_2}$, we have that $T_1\left(\mathbf{v}\right)\ge T_2\left(\mathbf{v}\right)$. The intuitive idea is that $T_2$ contains more or the same information than $T_1$ (any true assignment satisfying $T_2$ will also satisfy $T_1$).

The following properties of this relation are immediate:

• If T is a table and $V^{\prime }\subseteq V$, then $T^{-V^{\prime }}⪯T$;
• If $T_1$ and $T_2$ are tables, then $T_1⪯(T_1\otimes T_2)$;
• If $T_1,T_2,T_3$ are tables, then $(T_1\otimes T_2)⪯T_3$ if and only if $T_1⪯T_3$ and $T_2⪯T_3$.

Two tables, $T_1$ and $T_2$, are said to be equivalent, $T_1\equiv T_2$, if and only if $T_1⪯T_2$ and $T_2⪯T_1$. If $T_1$ and $T_2$ are defined on $V_1$ and $V_2$, respectively, and $T_e^1$ and $T_e^2$ are the neutral tables in ${\mathcal{T}}_{V_2\backslash V_1}$ and ${\mathcal{T}}_{V_1\backslash V_2}$, respectively, we can immediately prove that $T_1$ and $T_2$ are equivalent if and only if $T_1\otimes T_e^1=T_2\otimes T_e^2$. The multiplication by the neutral element is necessary for tables to be defined for the same set of variables. If $T_1$ and $T_2$ are equivalent and $V\left(T_1\right)=V\left(T_2\right)$, then they are identical, i.e., $T_1=T_2$. The quotient set of $\mathcal{T}$ under this equivalence relation is called the domain-free valuation algebra associated with the valuation algebra [3]. In the following, we will consider that we work with equivalent classes of tables, and that a table can be changed into any equivalent one. All the neutral tables $T_e$ defined in different sets of variables are equivalent. Furthermore, the contradictory tables $T_0$ are equivalent. As a consequence, we will not make reference to the set of variables in which they are defined.

There is a disjunction operation [3,8] which can be defined on the set of tables: if $T_1$ and $T_2$ are tables, then its disjunction is the table $T_1\oplus T_2$ defined for the set of variables $V=V\left(T_1\right)\cup V\left(T_2\right)$ and given by:

$$(T_1\oplus T_2)\left(\mathbf{v}\right)=max\{T_1\left(\mathbf{v}\right),T_2\left(\mathbf{v}\right)\}.$$

It is immediately clear that disjunction is commutative and associative. Furthermore, that combination satisfies the distributive property with respect to disjunction and disjunction is also distributive with respect to the combination. In fact, we have the Boolean information algebra from [3], being the complementary to T in the table $T^c=1-T$.

We have some interesting properties relating disjunction with the basic table operations.

Proposition 1.

If T is a table and $v\in V\left(T\right)$, then $T^{-v}=U(T,v)\oplus U(T,\neg v)$.

Proof. 

See Proposition A1 in Appendix A.    □

Proposition 2.

If $T_1$ and $T_2$ are tables and $v\in V\left(T_1\right)\cap V\left(T_2\right)$, then ${(T_1\oplus T_2)}^{-v}=T_1^{-v}\oplus T_2^{-v}$.

Proof. 

See Proposition A2 in Appendix A.    □

4. Deletion Algorithm with Tables

We assume that we have some information represented by a set of tables: $H=\{T_1,\dots ,T_k\}$. This set is intended to be a representation of the combination: $\otimes \left(H\right)=T_1\otimes \cdots \otimes T_k$. As the size of the tables increases exponentially with the number of dimensions of the tables and $V(\otimes \left(H\right))={\bigcup }_{i=1}^{k}V\left(T_i\right)$, then the representation by a set can use much less space than the representation by a single table (except when the tables are defined for the same set of variables, but this is never the case according to our procedure to build the initial tables). $V(\otimes (H\left)\right)$ will be denoted as $V\left(H\right)$. The total size of the tables in H will be ${\sum }_{T\in H}{2}^{\left|V\right(T\left)\right|}$. For example, if we have three tables defined for variables $\{p_1,p_2\},\{p_2,p_3,p_4\},\{p_4,p_5,p_6\}$, the size of the tables will be $4+8+8=16$, but their combination will be defined for $V\left(H\right)=\{p_1,p_2,p_3,p_4,p_5\}$, which corresponds to a table of size 32.

If $V=V(\otimes (H\left)\right)$, vector $\mathbf{v}\in {\mathsf{\Omega }}_V$ satisfies the set of tables H when $T_i\left(\mathbf{v}\right)=1$ for any $T_i\in H$.

We will say that two sets, $H_1,H_2$, are equivalent if and only if $\otimes \left(H_1\right)$ is equivalent to $\otimes \left(H_2\right)$. We also say that $H_1⪯H_2$ when $\otimes \left(H_1\right)⪯\otimes \left(H_2\right)$.

The following properties are immediate:

• If $H_1$ and $H_2$ are equivalent, then $H\cup H_1$ will be equivalent to $H\cup H_2$;
• $H_1⪯H_2$ if and only if $\left\{T\right\}⪯H_2$ for any $T\in H_1$;
• If $H^{\prime }\subseteq H$, then $(H\backslash H^{\prime })\cup \otimes \left(H^{\prime }\right)$ is equivalent to H;
• If $H^{\prime }⪯H$, then $H^{\prime }\cup H$ is equivalent to H.

The set of true assignments of a set H will be the $\mathbf{T}\left(H\right)={\bigcap }_{T\in H}\mathbf{T}\left(T\right)$, where the intersection of two sets defined on different sets of indexes is defined as follows: if $R_1\subseteq {\mathsf{\Omega }}_{V_1},R_2\subseteq {\mathsf{\Omega }}_{V_2}$, then $R_1\cap R_2=\{\mathbf{v}\in {\mathsf{\Omega }}_{V_1\cup V_2}:{\mathbf{v}}^{-V_2\backslash V_1}\in R_1,{\mathbf{v}}^{-V_1\backslash V_2}\in R_2\}.$

The operations with tables can be translated to set of tables, taking into account that an operation on set H is really carried out on $\otimes \left(H\right)$ and that equivalent tables represent the same information. Some operations can be carried out in a simple way:

• The combination can be completed by a simple union:

  $$H_1\otimes H_2=H_1\cup H_2.$$
• The disjunction of sets of tables can be computed as follows:

  $$H_1\oplus H_2=\{T_1\oplus T_2:T_1\in H_1,T_2\in H_2\}.$$
• The conditioning is the conditioning of its tables:

  $$U(H,\mathcal{l})=\left\{U\right(T,\mathcal{l}):T\in H\}.$$

The deletion of variables is the more complex operation for sets of tables. In the following, we describe several methods to carry out this operation.

The marginal problem is as follows: given a set of tables, H, and $V^{\prime }\subseteq V\left(H\right)$, then compute $H^{\prime }$ such that $\otimes \left(H^{\prime }\right)$ is equivalent to $\otimes {\left(H\right)}^{-V^{\prime }}$. This set will also be denoted as $H^{-V}$, considering that we are computing an element of the equivalence class.

As tables satisfy the basic Shenoy–Shafer axioms, the marginalization can be computed with basic Algorithm 2, which is very similar to Algorithm 1, but now expressed as a marginalization algorithm and with information represented by tables. Procedure Marginalize0 ($H_v$) is very simple and it is depicted in Algorithm 3, where the condition of T equivalent to $T_0$ seems a bit artificial and unnecessary; it was included to show the similarity with other variants of this operation that we will introduce. When implemented, this test is also carried out, and when T is equivalent to $T_0$, we return the contradictory table which is defined for the empty set of variables and contains a single 0 value.

Algorithm 2 Deletion algorithm

Require:  H, a set of tables. Require:  $V^{\prime }$, a set of variables to remove. Ensure:  $H^{\prime }$, a set of tables representing $H^{-V^{\prime }}$.   1: procedure Deletion (H, $V^{\prime }$)   2:       for $v\in V^{\prime }$ do   3:           $H_v\leftarrow$ tables $T\in H$ such that $v\in V\left(T\right)$   4:           $(R_1,R_2)\leftarrow$ Marginalize0 ($H_v$, v)   5:           if $R_1$ contains $T_0$ then   6:                return $\left\{T_0\right\}$   7:           else   8:                $H\leftarrow (H\backslash H_v)\cup R_1$   9:           end if   10:      end for   11:      return H   12: end procedure

This algorithm can be used to solve the satisfiability problem: if for function Deletion(H, $V^{\prime }$), $V^{\prime }=V\left(H\right)$, then all the variables are removed and H will only contain tables defined for the empty set of variables which have a single value. Taking into account that trivial $T_e=1$ tables are not introduced, there are only two possibilities: H contains $T_0$ and then the problem is unsatisfiable or $H=\varnothing$ and the problem is satisfiable. However, the algorithm can also be used to compute marginal information and to compile the information in initial set H. This compilation is based on the following result.

Algorithm 3 Basic version of marginalize

Require:  $H_v$, a set of tables containing variable v. Require:  v, the variable to remove Ensure:  $R_1$, a set of tables representing $H_v^{-v}$. Ensure:  $R_2$, a set of tables containing v.   1: procedure Marginalize0 ($H_v$, v)   2:      $T_1\leftarrow \otimes \left(H_v\right)$   3:      $T_2\leftarrow T_1^{-v}$   4:      if $T_2$ is equivalent to $T_e$ then   5:           $R_1\leftarrow \varnothing$   6:      else   7:           if $T_2$ is equivalent to $T_0$ then   8:               $R_1\leftarrow \left\{T_0\right\}$   9:           else   10:              $R_1\leftarrow \left\{T_2\right\}$   11:          end if   12:      end if   13:      $R_2\leftarrow \left\{T_1\right\}$   14:      return $(R_1,R_2)$   15: end procedure

Proposition 3.

In each application of  Marginalize0 ($H_v$) , we have that $H_v$ is equivalent to $R_1\cup R_2$. Furthermore, if we bring $H^{\prime }$ into the update set H, computed in Step 8 of Algorithm 2, then H is equivalent to $H^{\prime }\cup R_2$.

Proof. 

See Proposition A3 in Appendix A.    □

As a consequence of this result, when applying the deletion algorithm, if we call $R_2\left[v\right]$ to the $R_2$ set which is obtained after removing variable v, we have that H is equivalent to $\left({\bigcup }_{v\in V\left(H\right)}{R}_2\left[v\right]\right)\cup H^{-V\left(H\right)}$. It is important to remark that $H^{-V\left(H\right)}$ is the result of removing all the variables, and then a table from this set is defined for the empty set of variables, which is a number. There are two possibilities: first, if H is satisfiable, then all the tables are 1 ($T_e$) and can be removed, representing $H^{-V\left(H\right)}$ by the empty set. Second, if H is unsatisfiable, $H^{-V\left(H\right)}$ will contain $T_0$, and the full H is equivalent to it: $\left\{T_0\right\}$. Let us call this set $R_2[\varnothing ]$.

If $H\left(V\right)=\{v_1,\dots ,v_k\}$ and the variables are removed in this order: $(v_1,\dots ,v_k)$, then we have that $H^{-\{v_1,\dots ,v_i\}}$ is equivalent to $\left({\bigcup }_{j=i+1}^k{R}_2\left[v_j\right]\right)\cup R_2[\varnothing ]$. Therefore, $H^{-\{v_1,\dots ,v_i\}}$ is equivalent to $H^{-\{v_1,\dots ,v_{i+1}\}}\cup R_2\left[v_{i+1}\right]$. In this way, we do not only compute the marginal information, but with sets $R_2\left[v_i\right]$, we have the necessary information to recover in a backward way the marginal sets: from the marginal in which all the variables are removed, $R_2[\varnothing ]$, to the marginal in which no variable is removed, H. This fact can be useful, among other things to obtain the true assignments satisfying all the tables, in case they are satisfiable. The following result provides a procedure to obtain the true assignments satisfying a set of tables H computed from sets of tables $\left\{R_2\left[v_i\right]\right\}$ obtained when applying a deletion algorithm.

Proposition 4. 

Assume a set of tables H and that Algorithm 2 is applied removing variables in $V\left(H\right)$ in order $(v_1,\dots ,v_k)$. Assume also that $R_2[\varnothing ]$ is equivalent to the empty set, i.e., the problem is satisfiable; then, if ${\mathbf{T}}_i$ is the set of true assignments satisfying the set of tables $H^{-\{v_1,\dots ,v_i\}}$ and ${\mathbf{T}}_0$ is the true assignments of H, then these sets can be computed in reverse order of $i=1,\dots ,k$ in the following way:

• Start with ${\mathbf{T}}_i=\varnothing$;
• Make ${\mathbf{T}}_k$ equal to the set containing an empty vector ${\mathbf{v}}_0\in {\mathsf{\Omega }}_{\varnothing }$;
• For each ${\mathbf{v}}_{i+1}\in {\mathbf{T}}_{i+1}$, compute $T_{i+1}$, which is the only table in $U(R_2\left[v_{i+1}\right],{\mathbf{v}}_{i+1})$, which is a table defined only for variable $v_{i+1}$, then this table is never equal to $T_0$, and if ${\mathbf{v}}_i^1$ and ${\mathbf{v}}_i^2$ are the true assignments obtained by extending ${\mathbf{v}}_{i+1}$ to variables $\{v_{i+1},\dots ,v_k\}$ and given by ${\mathbf{v}}_i^1=(v_{i+1},{\mathbf{v}}_{i+1}),{\mathbf{v}}_i^2=(\neg v_{i+1},{\mathbf{v}}_{i+1})$, i.e., by considering $v_{i+1}$ true and false, respectively, then:

  −

  if $T_{i+1}=T_e$, add ${\mathbf{v}}_i^1$ and ${\mathbf{v}}_i^2$ to ${\mathbf{T}}_i$;

  −

  if $T_{i+1}\left(v_{i+1}\right)=1,T_{i+1}(\neg v_{i+1})=0$, add ${\mathbf{v}}_i^1$ to ${\mathbf{T}}_i$;

  −

  if $T_{i+1}\left(v_{i+1}\right)=0,T_{i+1}(\neg v_{i+1})=1$, add ${\mathbf{v}}_i^2$ to ${\mathbf{T}}_i$.

Proof. 

See Proposition A4 in Appendix A.   □

This result is the basic for algorithms to compute one solution, all the solutions, or a random solution given a satisfiable set of clauses. It should start with a ${\mathbf{T}}_k$, which is a set containing an empty vector ${\mathbf{v}}_0\in {\mathsf{\Omega }}_{\varnothing }$. The main difference in these algorithms is when $T_{i+1}=T_e$. When computing one solution, we only pick ${\mathbf{v}}_i^1$ or ${\mathbf{v}}_i^2$, when computing all the solutions, both ${\mathbf{v}}_i^1$ and ${\mathbf{v}}_i^2$ are selected, and when computing a random solution, there is a random selection of ${\mathbf{v}}_i^1$ or ${\mathbf{v}}_i^2$. In the last case, an importance sampling algorithm in the set of solutions is obtained: starting with a weight of $1.0$, each time we have a random selection, the weight must be multiplied by $2.0$.

In Algorithm 3, we have described the basic marginalization operation, which is the same as the one applied to the general valuation-based systems [2]. However, Boolean tables allow other alternative forms of marginalization. The first one is depicted in Algorithm 4 and determines that it is not necessary to combine all the tables in order to compute the marginal. In fact, only pairwise combinations are necessary.

Algorithm 4 Pairwise combination version of marginalize

Require:  $H_v$, a set of tables containing variable v. Require:  v, the variable to remove Ensure:  $R_1$, a set of tables representing $H_v^{-v}$. Ensure:  $R_2$, a set of tables containing v.   1: procedure Marginalize1 ($H_v$, v)   2:      $R_1=\{{(T_i\otimes T_j)}^{-v}:T_i,T_j\in H_v\}$   3:      $R_2\leftarrow H_v$   4:      if $R_1$ contains $T_0$ then   5:           $R_1\leftarrow \left\{T_0\right\}$   6:      end if   7:      Remove neutral tables $T_e$ from $R_1$   8:      return $(R_1,R_2)$   9: end procedure

The following proposition shows that $R_1$ is also a set of tables representing $H_v^{-v}$.

Proposition 5.

If $H_v$ is a set of tables containing variables v, then $R_1$ computed in Algorithm 4 represents $H_v^{-v}$.

Proof. 

See Proposition A5 in Appendix A.   □

Once this is proved, then we can replace Marginalize0 by Marginalize1 in the deletion algorithm and everything works, even the method to compute the solutions given in Proposition 4. The only difference is that now $R_2\left[v_{i+1}\right]$ contains, in general, more than one table, and when computing $U(R_2\left[v_{i+1}\right],{\mathbf{v}}_{i+1})$, we have to condition every table in $R_2\left[v_{i+1}\right]$, being the result a set of tables depending on variable $v_{i+1}$. These tables are combined to produce $T_{i+1}$.

The main difference between Marginalize0 and Marginalize1 is that the former produces an unique table in $R_1$ and $R_2$, while the latter produces several tables in both sets, but with smaller size. As the size of a table T is $2^{\left|V\right(T\left)\right|}$, in general, Marginalize1 is more efficient, but we have to take into account that the number of tables in $R_1$ is quadratic in relation with the number of tables in $H_v$ and this fact should be taken into account.

However, there is another very important alternative marginalization when we have a variable which is functionally dependent of other variables [20]. This happens very often, especially in problems encoding circuits [21].

If T is a table and $v\in V\left(T\right)$, we say that v is functionally determined in T if and only if $U(T,v)\otimes U(T,\neg v)$ is equivalent to $T_0$. If $V^{\prime }=V\left(T\right)\backslash \left\{v\right\}$, this implies that for any ${\mathbf{v}}^{\prime }\in {\mathsf{\Omega }}_{V^{\prime }}$ we have that $(U(T,v)\otimes U(T,\neg v))\left({\mathbf{v}}^{\prime }\right)=0$, i.e., either $U(T,v)\left({\mathbf{v}}^{\prime }\right)=T({\mathbf{v}}^{\prime },v)=U(T,{\mathbf{v}}^{\prime })\left(v\right)=0$ or $U(T,\neg v)\left({\mathbf{v}}^{\prime }\right)=T({\mathbf{v}}^{\prime },\neg v)=U(T,{\mathbf{v}}^{\prime })(\neg v)=0$, i.e., for each ${\mathbf{v}}^{\prime }$, there is, at most, one possible value for variable V, v or $\neg v$ for which table T has a value of 1 (at least, one of the values v or $\neg v$ is impossible). This definition generalizes definition given in terms of clauses in [20], which also requires that $T^{-v}$ is equivalent to the neutral element.

In the case that there is a table $T\in H_v$ such that v is functionally determined on T, then marginalization can be done as in Algorithm 5.

This marginalization is much more efficient, as the number of the tables in $R_1$ is smaller than in Marginalize1. In fact, the number of tables in the problem does not increase: the number of tables in $R_1$ is always less or equal than the number of tables in $H_v$. We give an example illustrating the benefits of using this marginalization.

Algorithm 5 Marginalize with functional dependence

Require:  $H_v$, a set of tables containing variable v. Require:  v, the variable to remove Require:  T a table in which v is functionally determined Ensure:  $R_1$, a set of tables representing $H_v^{-v}$. Ensure:  $R_2$, a set of tables containing v.   1: procedure Marginalize2 ($H_v$, v, T)   2:      $R_1=\{{(T\otimes T^{\prime })}^{-v}:T^{\prime }\in H_v\}$   3:      $R_2\leftarrow \left\{T\right\}$   4:      if $R_1$ contains $T_0$ then   5:           $R_1\leftarrow \left\{T_0\right\}$   6:      end if   7:      Remove neutral tables $T_e$ from $R_1$   8:      return $(R_1,R_2)$   9: end procedure

Example 2.

Assume that we are deleting variable p and that we have three tables:

$$T_1(p,q),T_2(p,r,s),T_3(p,u,v).$$

If  Marginalize0 is applied, then we have to combine the three tables producing a table $(T_1\otimes T_2\otimes T_3)(p,q,r,s,u,v)$, which depends on six variables and has a size of 64. If Marginalize1 is applied, then we have to compute $(T_1\otimes T_2)(p,q,r,s),(T_1\otimes T_3)(p,q,u,v),(T_2\otimes T_3)(p,r,s,u,v)$ (the combination of a table by itself is not necessary, as this produces the same table which is included in one of these combinations), i.e., we have more tables but of smaller size (16 + 16 + 32). However, if it is known that p is determined by q in table $T_1$, then, for  Marginalize2, only combinations $(T_1\otimes T_2)(p,q,r,s),(T_1\otimes T_3)(p,q,u,v)$ are necessary and the result is based on two tables of sizes 16+16, producing an important saving in space and computation. Please note that to finish the marginalization step, variable p should be removed on the computed tables by marginalization, but this step has been omitted in order to keep the notation simpler.

This marginalization is correct, as $R_1$ is equivalent to $H_v^{-v}$ and $H_v$ is equivalent to $R_1\cup R_2$, as the following results shows.

Proposition 6.

If $(R_1,R_2)$ are the sets computed in  Marginalize2 and the initial conditions required by the algorithm are satisfied; then, $H_v^{-v}$ is equivalent to $R_1$ and $H_v$ is equivalent to $R_1\cup R_2$.

Proof. 

See Proposition A6 in Appendix A.   □

5. Additional Processing Steps and Marginalization Strategy

In this section, we introduce some additional steps which can be added to the basic deletion algorithm to improve efficiency or to enlarge the family of problems that can be solved.

5.1. Combining Tables

Many times we have in a problem two tables $T_1$ and $T_2$, such that $V\left(T_1\right)\subseteq V\left(T_2\right)$. We can substitute them by its combination $T=T_1\otimes T_2$ obtaining an equivalent problem. Doing this can have potential advantages: it reduces the size of the problem specification, as the size of T is the same than the size of $T_2$, but it also increases the chances of having a variable which is functionally dependent of the others. Remember that v is determined in T when $U(T,v)\otimes U(T,\neg v)=T_0$, so if $T⪯T^{\prime }$, then v will be also determined in $T^{\prime }$. We can consider the procedure CombineIncluded(H) which compares the sets of variables of each pair of tables $T_1,T_2\in H$, and substitutes the pair by its combination when one set is included in the other. One important point is the sets to which this procedure applies. In Algorithm 2, CombineIncluded(H) could be applied to the set H after each deletion of a variable, to the set $H_v$, or to $R_1$. Applying it to H could be very costly, as the number of tables can be high and we have to compare all the pairs of tables. A similar effect can be obtained by applying it to set $H_v$, which are the tables effectively used in each deletion step, but which is of smaller size. It is also important to apply it to set $R_1$, as it can significantly reduce the number of tables, which can be high when Marginalizalize1 is used to delete a variable.

In the case of $H_v$, we have already implemented a more aggressive combination method, which combines two tables $T_1$ and $T_2$ when $2^{V(T_1\otimes T_2)}\le 2^{V\left(T_1\right)}+2^{V\left(T_2\right)}$. This always happens when $V\left(T_1\right)\subseteq V\left(T_2\right)$, but also when $|V\left(T_1\right)|=|V\left(T_2\right)|$ and $V\left(T_1\right)=V\left(T_2\right)\backslash \left\{u\right\}\cup \left\{v\right\}$, i.e., tables are defined for the same variables, except for variables $u\in V\left(T_2\right),v\in V\left(T_1\right)$. We will call to this procedure GroupTables(H), which will be applied to $H_v$ in the case of Marginalize1 when the number of tables in H is greater or equal is greater or equal than a given threshold, N.

Example 3.

Assume three tables, i.e., $T_1$ for variables $p,q$, $T_2$ for variables $q,r$, and $T_3$ for variables $p,r$, that are given by:

$$\begin{array}{|cc|}\hline (p,q)& 1\\ (p,\neg q)& 0\\ (\neg p,q)& 1\\ (\neg p,\neg q)& 1\\ \hline\end{array},\begin{array}{|cc|}\hline (q,r)& 0\\ (q,\neg r)& 1\\ (\neg q,r)& 1\\ (\neg q,\neg r)& 1\\ \hline\end{array},\begin{array}{|cc|}\hline (p,r)& 1\\ (p,\neg r)& 1\\ (\neg p,r)& 0\\ (\neg p,\neg r)& 1\\ \hline\end{array}$$

If GroupTables(H) is applied, then tables $T_1$ and $T_2$ are combined, as the result has a size of 8 and the combined tables sizes are 4 + 4. Then, table $T_3$ is also combined, as it is defined for a set of variables included in the variables of the combination of $T_1\otimes T_2$. The result is that the three tables are replaced by their combination, which is given by the following table:

$$\begin{array}{|cc|}\hline (p,q,r)& 0\\ (p,q,\neg r)& 1\\ (p,\neg q,r)& 0\\ (p,\neg q,\neg r)& 0\\ (\neg p,q,r)& 0\\ (\neg p,q,\neg r)& 1\\ (\neg p,\neg q,r)& 0\\ (\neg p,\neg q,\neg r)& 1\\ \hline\end{array}$$

Observe that this table is smaller than the sum of the sizes of the three combined tables. Furthermore, in the combination, we can observe that r is determined by $(p,q)$, for which  Marginalize2 can be applied.

5.2. Unidimensional Arrays

Unidimensional arrays have a special consideration. If we are going to introduce in H a table T and $\left|V\right(T\left)\right|=1$, then there are three possibilities:

• T is equal to $T_e$, the neutral element. In this case, the table is not introduced in H.
• T is equal to $T_0$, the contradiction. In this case, the whole set is equivalent to $\left\{T_0\right\}$ and all the other tables are removed from H. In fact, in our implementation, the equality to $T_0$ is checked for any table to be introduced to H, whatever its dimension is.
• In T, there is a value with value 0 and other with value 1. If ℓ is the literal with value 1, this table is equivalent to the unit literal ℓ and we can carry out a unit propagation. This is done by transforming any other table $T^{\prime }\in H$ into $U(T^{\prime },\mathcal{l})$ and finally introducing table T. In our implementation, instead of introducing the table T, we keep a set of unit literals, and each time another table is introduced in H, the conditioning to the literals in this set is carried out.

Example 4.

Consider the table $T^{\prime }$ about $p,q$ given by:

$$\begin{array}{|cc|}\hline (p,q)& 1\\ (p,\neg q)& 0\\ (\neg p,q)& 1\\ (\neg p,\neg q)& 1\\ \hline\end{array}$$

If a table, T, with p is introduced with $T(\neg p)=1,T\left(p\right)=0$, then we can transform table $T^{\prime }$ into $U(T^{\prime },\neg p)$, which is again an unidimensional table defined for q with $U(T^{\prime },\neg p)\left(q\right)=1,U(T^{\prime },\neg p)(\neg q)=0$. This table may produce further simplifications of tables containing variable q.

5.3. Splitting

The size of the tables in $H_v$ is important when applying the deletion step: the smaller the size, the faster this step can be completed. For that reason, we have implemented a procedure to reduce this size. In order to do this, for each $T\in H_v$, Algorithm 6 is applied, where Minimize ($T_1$,$T_2$, T, V) is a procedure that tries to make $T_1$ as smaller as possible (by marginalization) under the condition that $T=T_1\otimes T_2$ and that variables in V cannot be removed. The details of this minimizing algorithm can be found in Algorithm 7.

When this split is applied to any table T in $H_v$, each time T is split into $T_1,T_2$ with $|V\left(T_1\right)|<|V\left(T\right)|$, then T is changed to $T_1,T_2$ in H and to $T_1$ in $H_v$. The general procedure making this transformation is called SplitG($H_v$, H).

Algorithm 6 Splitting a table before deleting a variable

Require:  T, a table containing variable v. Require:  v, the variable to remove Ensure:  $T_1$, a table containing v. Ensure:  $T_2$, a table not containing v.   1: procedure Split(T, v)   2:       $T_2\leftarrow T^{-v}$   3:       $T_1\leftarrow T$   4:       $T_1\leftarrow$ Minimize($T_1$,$T_2$, T, $\left\{v\right\}$)   5:       return $(T_1,T_2)$   6: end procedure

Algorithm 7 Minimizing the splitting table

Require:  $T_1,T_2,T$, tables such that $T_1\otimes T_2=T$. Require:  V, a set of variables that can not be removed. Ensure:  M a table in which $T_1$ is minimized.   1: procedure Minimize($T_1$,$T_2$, T, V)   2:       if $V\left(T_1\right)\backslash V=\varnothing$ then   3:            $M\leftarrow T_1$   4:            return M   5:       end if   6:       Let v be an element from $V\left(T_1\right)\backslash V$   7:       $T_3\leftarrow T_1^{-v}$   8:       if $T_3\otimes T_2=T$ then   9:            return Minimize($T_3$, T, $T_2$, $V\cup \left\{v\right\}$)   10:      else   11:           return Minimize($T_1$, T, $T_2$, $V\cup \left\{v\right\}$)   12:      end if   13: end procedure

Example 5.

Assume that in our set of tables, we have a table T with variables $p,q,r$ given by:

$$\begin{array}{|cc|}\hline (p,q,r)& 1\\ (p,q,\neg r)& 0\\ (p,\neg q,r)& 0\\ (p,\neg q,\neg r)& 0\\ (\neg p,q,r)& 1\\ (\neg p,q,\neg r)& 0\\ (\neg p,\neg q,r)& 1\\ (\neg p,\neg q,\neg r)& 1\\ \hline\end{array}$$

If we want to remove variable r, then instead of using this table, we can try to split it into two tables, one of them not depending on r. Then we first compute the marginal $T_2=T^{-r}$, which is given by:

$$\begin{array}{|cc|}\hline (p,q)& 1\\ (p,\neg q)& 0\\ (\neg p,q)& 1\\ (\neg p,\neg q)& 1\\ \hline\end{array}$$

Next, we minimize T conditioned to $T_2$ obtaining in this case the following table $T_1$:

$$\begin{array}{|cc|}\hline (q,r)& 1\\ (q,\neg r)& 0\\ (\neg q,r)& 1\\ (\neg q,\neg r)& 1\\ \hline\end{array}$$

In this way, we obtain the decomposition $T=T_1\otimes T_2$; we can change T in our set of tables by the two tables $T_1,T_2$, and then, as $T_2$ does not depend on r, when deleting this variable, only $T_1$ has to be considered, which has a lower dimension than the original table T, simplifying in this way the deletion step.

5.4. Minimizing the Dependence Set

If we have the set of tables $H_v$ and there is a table $T\in H_v$ in which v is functionally determined, then the deletion is, in general, quite efficient, but it also depends on the size of T. If there is a table $T_m$ that can be obtained from T by marginalization and v continues being determined in $T_m$, then the result is also correct if we call Marginalize2 ($H_v$, v,$T_m$). The reason is very simple: as $T_m$ is obtained by marginalization of a table in $H_v$, then $H_v\cup \left\{T_m\right\}$ is equivalent to $H_v$ and Marginalize2 ($H_v\cup \left\{T_m\right\}$, v,$T_m$) produces a correct result. The only difference between Marginalize2 ($H_v\cup \left\{T_m\right\}$, v,$T_m$) and Marginalize2 ($H_v$, v,$T_m$) is that in the former, ${(T_m\otimes T_m)}^{-v}$ is included. However, this table is less informative than ${(T\otimes T_m)}^{-v}$, which is included in Marginalize2 ($H_v$, v,$T_m$), and then the two results are equivalent.

The algorithm we have applied to compute a table $T_m$ with smaller size in which there is functional dependence is depicted in Algorithm 8, initially with $V=\left\{v\right\}$. In it, we assume that we have a function CheckDeter(T, v) that determines when v is functionally determined in T.

Algorithm 8 Minimizing the dependence of a variable in a table

Require:  T, a table. Require:  v, a variable which is determined in T. Require:  V, a set of variables which can not be deleted. Ensure:  $T_m$ a marginal table in which v continues being determined.   1: procedure MinDep(T, v, V)   2:      if $V\left(T\right)\backslash V=\varnothing$ then   3:          $T_m\leftarrow T$   4:      end if   5:      Let v be an element from $V\left(T\right)\backslash V$   6:      $T^{\prime }\leftarrow T^{-v}$   7:      if CheckDeter ($T^{\prime }$, v) then   8:          $T_m\leftarrow$ MinDep ($T^{\prime }$, v, $V\cup \left\{v\right\}$)   9:      else   10:          $T_m\leftarrow$ MinDep (T, v, $V\cup \left\{v\right\}$)   11:     end if   12:     return $T_m$   13: end procedure

Example 6.

Assume a table T about variables $p,q,r$ given by:

$$\begin{array}{|cc|}\hline (p,q,r)& 0\\ (p,q,\neg r)& 1\\ (p,\neg q,r)& 0\\ (p,\neg q,\neg r)& 1\\ (\neg p,q,r)& 1\\ (\neg p,q,\neg r)& 0\\ (\neg p,\neg q,r)& 1\\ (\neg p,\neg q,\neg r)& 0\\ \hline\end{array}$$

In this table, r is determined by $(p,q)$, but if $T^{-q}$ is computed, the result is:

$$\begin{array}{|cc|}\hline (p,r)& 0\\ (p,\neg r)& 1\\ (\neg p,r)& 1\\ (\neg p,\neg r)& 0\\ \hline\end{array}$$

Furthermore, r is determined by p on it.  Marginalize2 is more efficient using this smaller table instead of the original one.

5.5. Alternative Deletion Procedures

When applying Marginalize0 ($H_v$, v), table $T=\otimes {\left(H_v\right)}^{-v}$ is computed. In some situations, it is possible that this table is of a small size, but Marginalize1 ($H_v$, v) or Marginalize2 ($H_v$, v) are applied. In that case, instead of computing $R_1$, an alternative method is to compute the maximal sets of the tables from $R_1$: $M\left(R_1\right)=\mathrm{Maximal}\{V\left(T^{\prime }\right):T^{\prime }\in R_1,V\left(T^{\prime }\right)\}$, where Maximal is removed from a family of sets, which are strictly included into another set of the family.

Observe that it is not necessary to actually compute the tables in $R_1$, but only the sets of variables associated with these tables.

Then, we can compute $R_1^{\prime }=\{T^{-V\left(T\right)\backslash B}:B\in M\left(R_1\right)\}$. When comparing $R_1$ and $R_1^{\prime }$ we can observe the following facts:

• Each element from $R_1$ is equal to $T^{\prime }={(T_i\otimes T_j)}^{-v}$, where $T_i,T_j\in H_v$ or a combination of several sets of this type, when CombinedIncluded has been applied. Then, there will be another table $T^{″}\in R_1^{\prime }$ defined for the same set of variables and computed as $T^{-V\left(T\right)\backslash V\left(T^{″}\right)}$. As $T^{″}$ is the result of marginalizing after combining all the tables, instead of combining only two tables, we have that $T^{\prime }⪯T^{″}$, and in some cases, the tables are not equivalent.
• The whole sets of tables $R_1$ and $R_1^{\prime }$ are equivalent. In fact, both are equivalent to $T=\otimes {\left(H_v\right)}^{-v}$. This is known for $R_1$. For $R_1^{\prime }$, as any element from $R_1^{\prime }$ is a marginalization of T, $R_1^{\prime }⪯\left\{T\right\}$. On the other hand, as a consequence of the above point, $R_1⪯R_1^{\prime }$, and as $R_1$ is equivalent to T, we have that $R_1^{\prime }$ is also equivalent to $\left\{T\right\}$.

Computing $R_1^{\prime }$ by computing T and $M\left(R_1\right)$ and performing marginalizations has, in general, a higher computational cost, but this may be lowered if T contains few variables; moreover, on the positive side, we have more informative tables in $R_1^{\prime }$ and there are more opportunities to find functional dependencies of variables in tables, which can improve the efficiency of posterior deletion steps.

In our implementations this decision is taken by fixing a threshold K, and if $\left|V\right(T\left)\right|\le K$, $R_1^{\prime }$ is computed. In other cases, $R_1$ is computed. The versions of Marginalize1 and Marginalize2 computing $R_1^{\prime }$ are called Marginalize1b and Marginalize2b, respectively.

Example 7.

Assume that we are going to delete p and that we have three tables $T_1,T_2,T_3$, defined for variables $(p,q),(p,r)$, and $(p,s)$, given by:

$$\begin{array}{|cc|}\hline (p,q)& 1\\ (p,\neg q)& 0\\ (\neg p,q)& 1\\ (\neg p,\neg q)& 1\\ \hline\end{array}\begin{array}{|cc|}\hline (p,r)& 1\\ (p,\neg r)& 0\\ (\neg p,r)& 1\\ (\neg p,\neg r)& 1\\ \hline\end{array}\begin{array}{|cc|}\hline (p,s)& 1\\ (p,\neg s)& 1\\ (\neg p,s)& 0\\ (\neg p,\neg s)& 0\\ \hline\end{array},$$

Assume that  Marginalize1 is applied and we are going to compute ${(T_1\otimes T_2)}^{-p},{(T_1\otimes T_3)}^{-p},{(T_2\otimes T_3)}^{-p}$, given by the following tables:

$$\begin{array}{|cc|}\hline (q,r)& 1\\ (q,\neg r)& 1\\ (\neg q,r)& 1\\ (\neg q,\neg r)& 1\\ \hline\end{array}\begin{array}{|cc|}\hline (q,s)& 1\\ (q,\neg s)& 1\\ (\neg q,s)& 0\\ (\neg q,\neg s)& 0\\ \hline\end{array}\begin{array}{|cc|}\hline (r,s)& 1\\ (r,\neg s)& 1\\ (\neg r,s)& 0\\ (\neg r,\neg s)& 0\\ \hline\end{array},$$

(1)

Alternatively, we can compute ${(T_1\otimes T_2\otimes T_3)}^{-\{p,s\}},{(T_1\otimes T_2\otimes T_3)}^{-\{p,r\}},{(T_1\otimes T_2\otimes T_3)}^{-\{p,q\}}$, which are defined for the same variables, obtaining:

$$\begin{array}{|cc|}\hline (q,r)& 1\\ (q,\neg r)& 1\\ (\neg q,r)& 1\\ (\neg q,\neg r)& \mathbf{0}\\ \hline\end{array}\begin{array}{|cc|}\hline (q,s)& 1\\ (q,\neg s)& 1\\ (\neg q,s)& 0\\ (\neg q,\neg s)& 0\\ \hline\end{array}\begin{array}{|cc|}\hline (r,s)& 1\\ (r,\neg s)& 1\\ (\neg r,s)& 0\\ (\neg r,\neg s)& 0\\ \hline\end{array}$$

(2)

The product of these three tables is equal to the product of the original tables in Equation (1). However, individually, each one of them can be more informative (has more 0’s) than the corresponding one in Equation (1). In this example, the first one has 0 assigned to $(\neg p,\neg q)$ in Equation (2), while this value was 1 in Equation (1).  Marginalize1b will compute the arrays in Equation (2).

5.6. The Final Global Marginalization Procedure

Now, we put everything together and describe the global marginalization procedure. In Algorithm 9, we describe the algorithm MarginalizeG, which gives a set H, and the variable v computes a set $H^{\prime }$ equivalent to $H^{-v}$ and other set $H^{″}$, such that H is equivalent to $H^{\prime }\cup H^{″}$. We assume that Determined ($H_v$, v) is a procedure that checks whether there is a table in $T\in H_v$ in which v is functionally determined. In that case, it returns MinDep ($T,v,\left\{v\right\}$). If this table does not exist, it returns the neutral element $T_e$.

The first thing is to test whether there is a functional dependence. In that case, Marginalize2 is applied, after minimizing the table with that dependence. If the size of the global combination is lower than a given threshold, then the version b of the marginalization is applied.

In another case, we have to choose between Marginalize0 and Marginalize1. For that, we first compute $M\left(R_1\right)$, the set of maximal sets of the sets of variables of the tables of $R_1$ after applying Marginalize1 and compare the size of the tables defined for these sets with the size of the table obtained with the basic Marginalize0, selecting the method with a smaller final size of the tables. If Marginalize1 is selected, then GroupTables is applied if the number of tables in $H_v$ is greater than a given threshold N.

Algorithm 9 The final global marginalization algorithm

Require:  H, a set of tables. Require:  v, the variable to remove Require:  W, a Boolean variable indicating the splitting procedure Require:  N, a threshold for grouping tables Require:  K, a threshold for the alternative deletion procedure Ensure:  $H^{\prime }$, a set of tables representing $H^{-v}$. Ensure:  $H^{″}$, a set of tables such that H is equivalent to $H^{\prime }\cup H^{\prime \prime }$.   1: procedure MarginalizeG (H, v)   2:      $H_v\leftarrow$ tables $T\in H$ such that $v\in V\left(T\right)$   3:      CombineIncluded ($H_v$)   4:      if W then   5:           SPLIT $(H_v,H)$   6:      end if   7:      $T\leftarrow$Determined ($H_v$, v)   8:      if $T\ne T_e$ then   9:            if $S(\otimes \left(H_v\right))\le K$ then   10:               $(R_1,R_2)\leftarrow$ Marginalize2b ($H_v$, v, T)   11:          else   12:               $(R_1,R_2)\leftarrow$ Marginalize2 ($H_v$, v, T)   13:          end if   14:      else   15:          $Q\leftarrow M\left(R_1\right)$                                   ▹ Maximal sets of $R_1$ after Marginalize1   16:          if $S(\otimes {\left(H_v\right)}^{-v})\le S\left(Q\right)$ then   17:              $(R_1,R_2)\leftarrow$ Marginalize0 ($H_v$, v)   18:          else   19:              if $|H_v|\ge N$ then   20:                 GroupTables ($H_v$)   21:             end if   22:             if $S(\otimes \left(H_v\right))\le K$ then   23:                  $(R_1,R_2)\leftarrow$ Marginalize1b ($H_v$, v)   24:             else   25:                  $(R_1,R_2)\leftarrow$ Marginalize1 ($H_v$, v)   26:             end if   27:          end if   28:      end if   29:      CombineIncluded ($R_1$)   30:      $H^{\prime }\leftarrow H\backslash H_v\cup R_1$   31:      $H^{\prime \prime }\leftarrow R_2$   32:      return $(H^{\prime },H^{\prime \prime })$   33: end procedure

6. Experiments

Computations with tables have been implemented using Python and the NumPy library [22]. For the basic operations with tables (combination, marginalization, and conditioning) we have taken as basis the implementation of the same operations in probabilistic calculus in the pgmpy library [23]. An important fact about the deletion algorithm is the order in which variables are chosen to be deleted. We have followed the usual heuristic of selecting the variable v with a minimum number of variables in $H_v$, but with the exception of the case in which v is not functionally determined in any table of $H_v$, but there is another variable $v^{\prime }$ that is determined in the table of $H_{v^{\prime }}$, and where $\left|V\right(H_{v^{\prime }}|-|V\left(H_v\right)|\le 2$. This is done to have a preference for selecting variables in which we can apply Marginalize2, which is the most efficient deletion procedure. We have carried out three experiments.

In the first experiment, we tested the basic deletion algorithms in several SAT examples imported from several repositories of benchmark problems for SAT, mainly from: Hoos and Stützle [24], Junttila [25], Tsuji and Gelder [26], and Burkardt [27]. The main criterion for selecting the cases has been that the size of the arrays does not surpass the maximum array size of 32 that exists in the NumPy library. The characteristics of the examples can be found in

Table 1. Benchmark problems used in the experiments.

Benchmark	Variables	Clauses	Max Cluster Size	Sol
SATHolV42C133.cnf	42	133	28	SAT
SATPlanV48C261.cnf	48	261	21	SAT
UNSATaimV50C80.cnf	50	80	16	UNSAT
UNSATaimV50C100.cnf	50	100	31	UNSAT
UNSATTmTbV112C245.cnf	112	245	18	UNSAT
SATTmTbV140C301.cnf	140	301	25	SAT
SATV300C1016.cnf	300	1010	28	SAT
aes_32_1_keyfind_1.cnf	300	1016	28	SAT
SATCircuitosV416C1136.cnf	416	1136	27	SAT
UNSATBFCircuitosV421C1000.cnf	421	1000	21	UNSAT
SATBFCircuitosV423C1010.cnf	423	1010	21	SAT
UNSATBFCircuitosV424C1031.cnf	424	1031	23	UNSAT
UNSATBFCircuitosV428C1037.cnf	428	1037	23	UNSAT
UNSATCircuitosV607C1808.cnf	607	1808	35	UNSAT
SATBFCircuitosV837C2169.cnf	837	2169	20	SAT
SATBFCircuitosV837C2169_2.cnf	837	2169	22	SAT
SATBFCircuitosV843C2286.cnf	843	2286	29	SAT
UNSATBFCircuitosV864C2790.cnf	864	2790	74	UNSAT
UNSATBFCircuitosV864C2790_2.cnf	864	2790	66	UNSAT
UNSATBFCircuitosV865C2783.cnf	865	2783	69	UNSAT
UNSATBFCircuitosV865C2783_2.cnf	865	2783	74	UNSAT
UNSATBFCircuitosV865C2784.cnf	865	2784	63	UNSAT
UNSATBFCircuitosV985C2324.cnf	985	2324	25	UNSAT
UNSATCircuitosV986C2315.cnf	986	2315	24	UNSAT
UNSATBFCircuitosV1040C3668_2.cnf	1040	3668	70	UNSAT
UNSATBFCircuitosV1040C3668.cnf	1040	3668	103	UNSAT
SATBFCircuitosV1207C2940.cnf	1207	2940	41	SAT
UNSATBFCircuitosV1339C3249.cnf	1339	3249	29	UNSAT
UNSATCircuitosV1355C3296.cnf	1355	3296	30	UNSAT
UNSATCircuitosV1359C3321.cnf	1359	3321	30	UNSAT
UNSATV1359C3321.cnf	1359	3321	30	UNSAT
UNSATBFCircuitosV1363C3361.cnf	1363	3361	31	UNSAT
UNSATBFCircuitosV1363C3361_2.cnf	1363	3361	27	UNSAT
UNSATBFCircuitosV1365C3369.cnf	1365	3369	27	UNSAT
UNSATBFCircuitosV1371C3383.cnf	1371	3383	31	UNSAT
UNSATBFCircuitosV1371C3383_2.cnf	1371	3383	26	UNSAT
UNSATBFCircuitosV1371C3401.cnf	1371	3401	30	UNSAT
UNSATBFCircuitosV1373C3391.cnf	1373	3391	33	UNSAT
UNSATBFCircuitosV1379C3417.cnf	1379	3417	26	UNSAT
UNSATBFCircuitosV1379C3417_2.cnf	1379	3417	33	UNSAT
UNSATBFCircuitosV1379C3423.cnf	1379	3423	29	UNSAT
UNSATBFCircuitosV1387C3439.cnf	1387	3439	27	UNSAT
UNSATBFCircuitosV1387C3439_2.cnf	1387	3439	27	UNSAT
UNSATBFCircuitosV1389C3440.cnf	1389	3440	26	UNSAT
UNSATBFCircuitosV1389C3440_2.cnf	1389	3440	25	UNSAT
UNSATCircuitosV1393C3434.cnf	1393	3434	26	UNSAT
UNSATBFCircuitosV1407C3496.cnf	1407	3496	26	UNSAT
UNSATBFCircuitosV1423C3609.cnf	1423	3609	38	UNSAT
UNSATBFCircuitosV1488C3859.cnf	1488	3859	21	UNSAT
SATCircuitosV1501C3575.cnf	1501	3575	26	SAT
SATCircuitosV2013C4795.cnf	2013	4795	29	SAT
UNSATCircuitosV2177C6768.cnf	2177	6768	65	UNSAT
UNSATCircuitosV2180C6778.cnf	2180	6778	70	UNSAT

. We also provide the maximum cluster size (number of variables) of a join tree built from the connectivity graph under the same ordering than used in our deletion algorithm. We have selected the problems with the restrictions that they are not too simple (a maximum cluster size of at least 15) and that the deletion algorithm can be applied, taking into account that the number of dimensions of a table in NumPy is limited to 32, i.e., it is required that for each table T, we have that $\left|V\right(T\left)\right|\le 32$.

We have applied the deletion algorithm with the general deletion step of Algorithm 9. In it, we have considered a value of $N=30$ for grouping tables when pairwise marginalization is applied. We have tested two variants of the algorithm $W=True$ and $W=False$ to test whether splitting is a good idea and a set of values of $K=5,10,15,20,25,30$.

First, we can observe that, in general, the problems are solved fast, with an average of less than 1 min for all the parameters settings.

With a non-parametric Friedman test, the differences between the different combinations of K and W are significant (p-value = 0.001149). The averages of times as a functions of K are depicted in Figure 1 for the case $W=False$ (the case $W=True$ is very similar). We can see that the time increases as a function of K, but being more or less constant for $K=10,15,20$. This increasing pattern does not always occur. For example, in aes_32_1_keyfind_1.cnf, the times with $W=False$ can be seen in Figure 2. In that case, it is possible to see that the optimal K is 15. The extra work of computing the global table is compensated by the presence of more zeros in the resulting tables, which speed up the consecutive deletions.

We have carried out a post hoc Conoven–Friedman test (without correction for multiple tests). The resulting p-values for pairwise comparisons can be seen in

Table 2. Results of the post hoc Conoven–Friedman test.

	K05N	K05Y	K10N	K10Y	K15N	K15Y	K20N	K20Y	K25N	K25Y
K05N	1.000000	1.000000	0.319196	0.974352	0.012449	0.403390	0.003590	0.007856	0.006494	0.067368
K05Y	1.000000	1.000000	0.319196	0.974352	0.012449	0.403390	0.003590	0.007856	0.006494	0.067368
K10N	0.319196	0.319196	1.000000	0.303853	0.131254	0.872292	0.054216	0.095066	0.083050	0.403390
K10Y	0.974352	0.974352	0.303853	1.000000	0.011374	0.385562	0.003242	0.007146	0.005897	0.062719
K15N	0.012449	0.012449	0.131254	0.011374	1.000000	0.095066	0.676013	0.872292	0.821945	0.499687
K15Y	0.403390	0.403390	0.872292	0.385562	0.095066	1.000000	0.037087	0.067368	0.058339	0.319196
K20N	0.003590	0.003590	0.054216	0.003242	0.676013	0.037087	1.000000	0.797032	0.847040	0.274662
K20Y	0.007856	0.007856	0.095066	0.007146	0.872292	0.067368	0.797032	1.000000	0.948731	0.403390
K25N	0.006494	0.006494	0.083050	0.005897	0.821945	0.058339	0.847040	0.948731	1.000000	0.368225
K25Y	0.067368	0.067368	0.403390	0.062719	0.499687	0.319196	0.274662	0.403390	0.368225	1.000000

. A ‘Y’ means that $W=True$ and an `N’ means that $W=False$. First, we can observe that there are never significant differences with the use of Split. There are significant differences of $K=25$ with the cases in which $K=5,10$, especially if Split is not applied. In this case, the computation of large tables does not compensate for the presence of more zeros. The comparison of $K=20$ is only significant with $K=5$. Again, the significance is higher with no Split. $K=15$ with Split shows no significant difference with any smaller value of K. There is only one small significance (with $\alpha =0.05$) if split is not applied.

To compare with previous versions of the DP algorithm, we have also implemented the basic Algorithm 2, as in [5], including a step for unit propagation (each time a unit clause is found, unit propagation is carried out). As this algorithm is less efficient, we have given it a limit of 600 s to solve each problem to avoid very long running times in some of the problems. For example, case aes_32_1_keyfind_1.cnf was not solved even with 2 h of running time. A total of 12 problems could not be solved within this time limit (600 s), and the average time was 168.08 s. This average is much larger than the worst case in our algorithms, even taking into account that the running time was limited to 600 s. A non-parametric Wilcoxon test was not significant. This is due to the fact that this approach was usually faster in the simpler problems.

In the second experiment, we consider four sets of clauses with 504, 708, 912, and 1116 variables and 1840, 2664, 3488, and 4312 clauses, respectively. Our exact algorithms were not able to solve these cases. However, we have computed the number of variables which have been deleted without surpassing a maximum table size of 25, for each combination of K and $W=True$ (the results were the same for $W=False$). We can observe that there is a tendency to delete, in an exact way, more variables when K increases, though this is not always true in each particular problem (

Table 3. Number of deleted variables.

	K05	K10	K15	K20	K25
aes_32_2_keyfind_1.cnf	412	421	421	417	430
aes_32_3_keyfind_1.cnf	570	580	580	576	576
aes_32_4_keyfind_1.cnf	726	716	716	734	732
aes_32_5_keyfind_1.cnf	873	864	865	882	880
TOTAL	2581	2581	2582	2609	2618

).

As a summary of the first two experiments, we find that the use of $K=5$ with Split is the best option, but we leave open the possibility of using higher values of K, especially in difficult problems.

The third experiment identifies a situation in which marginalization algorithms can be applied. For that, we consider the Bayesian networks used in the UAI 2022 competition (see https://uaicompetition.github.io/uci-2022/ (accessed on 10 May 2023)). We discarded the networks in which all the values in the conditional probability tables are non-zero (five networks) and the networks in which there were non-binary variables (three networks). This makes a total of 96 networks used in the partition function and the marginal probability competitions. The characteristics of these networks can be seen in

Table 4. Benchmarks used in Experiment 3.

Benchmark	$\mathit{nv}$	$\mathit{ne}$	$\mathit{mcs}$	$\mathit{p}0$	Benchmark	$\mathit{nv}$	$\mathit{ne}$	$\mathit{mcs}$	$\mathit{p}0$
Promedus_11	461	8	32	0.358	mastermind_04_08_03-0014	1418	48	24	0.491
Promedus_12	534	3	26	0.366	mastermind_04_08_03-0015	1418	48	24	0.491
Promedus_13	894	4	11	0.325	mastermind_04_08_04-0001	2616	36	39	0.494
Promedus_14	414	9	37	0.363	mastermind_04_08_04-0002	2616	36	39	0.494
Promedus_15	385	4	14	0.369	mastermind_04_08_04-0003	2616	36	39	0.494
Promedus_16	715	5	19	0.302	mastermind_04_08_04-0004	2616	36	39	0.494
Promedus_17	916	9	29	0.307	mastermind_04_08_04-0005	2616	36	39	0.494
Promedus_18	374	8	39	0.369	mastermind_05_08_03-0001	1616	27	28	0.490
Promedus_19	624	7	28	0.347	mastermind_05_08_03-0002	1616	27	28	0.490
Promedus_20	546	6	23	0.350	mastermind_05_08_03-0003	1616	27	28	0.490
Promedus_21	473	3	13	0.370	mastermind_05_08_03-0004	1616	27	28	0.490
Promedus_22	400	3	15	0.3339	mastermind_05_08_03-0009	1616	63	35	0.490
Promedus_23	674	9	28	0.320	mastermind_06_08_03-0002	1814	27	33	0.489
Promedus_24	200	4	5	0.294	mastermind_06_08_03-0003	1814	27	33	0.489
Promedus_25	1005	7	27	0.312	mastermind_06_08_03-0005	1814	27	33	0.489
Promedus_26	614	6	4	0.298	mastermind_06_08_03-0009	1814	83	41	0.489
Promedus_27	410	5	22	0.357	mastermind_10_08_03-0008	2606	769	57	0.486
Promedus_28	463	7	19	0.350	mastermind_10_08_03-0009	2606	404	56	0.486
Promedus_29	434	8	5	0.301	or_chain_4.fg	700	9	44	0.348
Promedus_30	306	13	7	0.298	or_chain_12.fg	468	11	42	0.361
Promedus_31	466	2	14	0.370	or_chain_15.fg	656	11	39	0.347
Promedus_32	511	2	13	0.329	or_chain_53.fg	741	13	45	0.348
Promedus_33	378	2	6	0.303	or_chain_61.fg	1028	7	46	0.336
Promedus_34	415	3	22	0.361	or_chain_64.fg	460	9	38	0.358
Promedus_35	467	2	14	0.371	or_chain_90.fg	512	9	42	0.357
Promedus_36	467	2	14	0.371	or_chain_102.fg	860	11	45	0.325
Promedus_37	1039	4	27	0.330	or_chain_106.fg	695	10	41	0.344
Promedus_38	668	5	36	0.353	or_chain_107.fg	631	11	50	0.349
BN_31	1156	120	66	0.448	or_chain_128.fg	648	11	54	0.352
fs-07	1225	1120	36	0.440	or_chain_132.fg	723	13	43	0.344
mastermind_03_08_04-0000	2288	0	31	0.495	or_chain_138.fg	702	11	40	0.350
mastermind_03_08_04-0001	2288	36	31	0.495	or_chain_140.fg	1268	8	43	0.331
mastermind_03_08_04-0002	2288	36	31	0.495	or_chain_149.fg	629	10	38	0.352
mastermind_03_08_04-0003	2288	36	31	0.495	or_chain_150.fg	928	6	38	0.347
mastermind_03_08_04-0007	2288	245	33	0.495	or_chain_153.fg	710	9	35	0.347
mastermind_03_08_04-0008	2288	355	32	0.495	or_chain_155.fg	542	11	42	0.356
mastermind_03_08_04-0010	2288	142	32	0.495	or_chain_161.fg	794	8	46	0.350
mastermind_03_08_04-0012	2288	64	31	0.495	or_chain_188.fg	1061	11	38	0.308
mastermind_03_08_04-0013	2288	64	31	0.495	or_chain_209.fg	859	10	38	0.341
mastermind_03_08_04-0014	2288	64	31	0.495	or_chain_242.fg	613	10	43	0.360
mastermind_03_08_04-0015	2288	64	31	0.495	blockmap_10_01-0009	5650	1078	56	0.499
mastermind_03_08_05-0001	3692	45	41	0.496	blockmap_10_02-0009	6252	1159	56	0.499
mastermind_03_08_05-0003	3692	45	39	0.496	blockmap_10_03-0009	6848	1844	60	0.499
mastermind_03_08_05-0009	3692	785	42	0.496	blockmap_10_03-0010	6848	1610	59	0.499
mastermind_04_08_03-0000	1418	0	24	0.491	blockmap_15_01-0008	16,497	6193	69	0.499
mastermind_04_08_03-0011	1418	48	24	0.491	blockmap_15_02-0008	17,649	5959	81	0.499
mastermind_04_08_03-0012	1418	48	24	0.491	blockmap_15_03-0010	18,787	6273	73	0.499
mastermind_04_08_03-0013	1418	48	24	0.491	blockmap_20_01-0009	39,297	15,222	105	0.499

, where $nv$ is the number of variables, $ne$ is the number of observed nodes, $mcs$ is the maximum cluster size (in a deletion algorithm with the original probability tables), and $p0$ is the percentage of 0 values in the original conditional probability tables. We can observe that the percentage of 0 values is very high in all the networks. We have to take into account that, being conditional probability tables for binary variables, at least 0.5 of the values are different from 0 (for each 0 value, there is another value equal to 1). Thus, in some networks with 0.455 values that are 0, this implies that only 0.002% of the values are different from 0 and 1. With these networks, we have solved the associated propositional problem. This problem is defined by transforming each conditional probability table T into a logical table $T^{\prime }$ in such a way that $T^{\prime }\left(\mathbf{v}\right)=0$ if $T\left(\mathbf{v}\right)=0.0$ and $T^{\prime }\left(\mathbf{v}\right)=1$, otherwise. If a variable v has been observed, then a unitary logical table is added with value 1 in the observed value and 0 in the unobserved one.

Then, we have applied our basic algorithm with $K=20$ and Split. All the problems were solved with an average time of 20.54 s (minimum of 0.035 s and maximum of 542.367 s). It is important to remark that most of the problems, 59 out of 96, were solved in less than 1 s, and almost all of them, 82 out of 96, were solved within a time limit of 10 s.

We have also applied the DP algorithm (Algorithm 2) to the equivalent set of clauses of the different problems. The average time was 200.736 s, but we need to take into account that there was a time limit of 2000 s and that nine problems were not solved within this time limit. The average, after taking into account the full resolution of these nine problems, would have been higher. This shows that our method was able of solving more problems and with less time, especially for difficult cases.

It is important to remark that the result of the deletion algorithms can be used to develop Monte Carlo algorithms to obtain compatible configurations according to Proposition 4, without rejecting any configuration due to a 0 probability. This is important for the development of approximate algorithms and it is not feasible with classical SAT algorithms deciding the satisfiability of the case and providing one satisfying assignment.

7. Conclusions and Future Work

In this paper, we have proposed a new procedure which can be applied to solve the marginalization problem in propositional logic based on the use of Boolean arrays. The experiments show that it is possible to solve, in an exact way, moderate-sized problems (even with thousands of variables and a tree width of more than 100). The method is based on a classical deletion algorithm but with some improvements based on the special characteristics of Boolean arrays. We have provided a full set of tools for working and operating with these arrays, allowing us to apply the Shenoy–Shafer abstract framework [2]. We have studied different methods for carrying out the deletion of a variable. Of special interest is the deletion of a variable when its value is functionally determined from the values of the other variables. Previous experiments with deletion algorithms [4,5] reported experiments in general problems, with up to 25 variables. They have also reported experiments with other problems, called ‘chain problems’, that were randomly generated in such a way that the tree width was bounded by 5, while we have been able of solving problems with a tree width of 103. We have shown that we have been able to expand the class of problems that can be solved with the deletion algorithm, as the previous versions were unable of solving the more difficult problems in our experiments. Some problems which could be solved in seconds with our approach could not be solved in hours with former basic deletion algorithm. This opens a new set of possibilities for algorithms to solve the marginal problem.

For the future, this framework opens a wide range of possible developments:

• To optimize the deletion strategy by selecting the most appropriate method depending on the characteristics of the tables in $H_v$.
• To improve the methods for decomposing a large table T as a product of smaller tables, which can be more useful. Of special interest is also to obtain tables of low dimensions, even if T is not decomposed as its product. The extreme case is a table of dimension 1, which always simplifies the problem (if different from the neutral element).
• To combine the clause representation and the table representation, as we have found that the basic clause representation was able of solving faster the simpler problems.
• To organize computations in a join tree with a local computation algorithm [2,6].
• To develop approximate algorithms. For example, the mini-bucket elimination algorithm [28] is a general framework for approximate algorithms based on partitioning the set $H_v$ before carrying out the combination of all the tables. In this case, we can have more opportunities based on the fact that potentials are idempotent and the alternative marginalization procedures we have provided.
• To combine approximate and exact computations. An approximate computation can be the basis to obtain small informative tables, which can be useful to speed up an exact algorithm.
• To develop a backtracking algorithm, taking as a basis the array representation.
• To approximate inference in Bayesian networks is NP-hard, especially when there are extreme probabilities [29]. Approximate algorithms, such as likelihood weighting [30] or penniless propagation [31], could take advantage of a previous and fast propagation of 0–1 values with the procedures proposed in this paper. Experiment 3 has already shown that our algorithms can propagate 0–1 values very fast in hard problems (from the UAI 2022 competition).
• The special role of potentials representing functional dependence could also be studied in the general framework of Information Algebras [32] and applied to other problems which are particular cases, such as constraint satisfaction [33].
• To consider the easy deletion of some variables in an SAT problem as a preprocessing step in SAT problems [34] that could be used as a simplification procedure.