Approximate Model Counting, Sparse XOR Constraints and Minimum Distance

TL;DR

This paper investigates the use of sparse XOR constraints in approximate model counting, linking the effectiveness of these constraints to the geometric structure of model sets, especially minimum Hamming distance.

Contribution

It introduces a theoretical analysis connecting sparse XOR constraints to model set geometry, providing insights for improving approximate counting methods.

Findings

Sparse XOR constraints can be effectively used with guarantees of correctness.

The bounds depend on the minimum Hamming distance between models.

Theoretical results are validated on specific Boolean formulas.

Abstract

The problem of counting the number of models of a given Boolean formula has numerous applications, including computing the leakage of deterministic programs in Quantitative Information Flow. Model counting is a hard, #P-complete problem. For this reason, many approximate counters have been developed in the last decade, offering formal guarantees of confidence and accuracy. A popular approach is based on the idea of using random XOR constraints to, roughly, successively halving the solution set until no model is left: this is checked by invocations to a SAT solver. The effectiveness of this procedure hinges on the ability of the SAT solver to deal with XOR constraints, which in turn crucially depends on the length of such constraints. We study to what extent one can employ sparse, hence short, constraints, keeping guarantees of correctness. We show that the resulting bounds are closely related to the geometry of the set of models, in particular to the minimum Hamming distance between models. We evaluate our theoretical results on a few concrete formulae. Based on our findings, we finally discuss possible directions for improvements of the current state of the art in approximate model counting.

Tables

Table 1. Table 1: Comparison with the provable bounds from [ 9 , Tab. 1] .

N. Vars	N. Constraints	$\lambda \times m$	$\lambda \times m$ present paper
(m)	(s)	from [9]	$d=1$	$d=5$	$d=20$
50	13	16.85	16.85	11.76	3.88
50	16	15.38	15.38	11.36	4.1
50	20	13.26	13.26	10.26	4.37
50	30	9.57	9.57	8.02	4.75
50	39	7.08	7.08	6.2	4.45
100	11	39.05	39.05	23.65	7.4
100	15	35.44	35.44	25.26	8.07
100	25	27.09	27.09	21.33	9.14
119	7	50.19	50.18	25.07	7.6
136	9	55.63	55.63	30.66	9.46
149	11	60.6	60.6	35.24	11.02
352	10	147.99	147.99	81.42	25.31

Table 2. Table 2: Results for our tool with α = β = 1.5 𝛼 𝛽 1.5 \alpha=\beta=1.5 , d = 1 𝑑 1 d=1 and d = d m ​ i ​ n 𝑑 subscript 𝑑 𝑚 𝑖 𝑛 d=d_{min} , compared to ApproxMC3 with a tolerance ϵ = 3 italic-ϵ 3 \epsilon=3 . In all trials, the error probability δ 𝛿 \delta is 0.1.

Formula	Our tool with d=1	Our tool with d=dmin	ApproxMC3
F21-31-5.cnf	res: $[2^{19.5},2^{23.5}]$	res: $[2^{19.5},2^{23.5}]$	res: ??
	time: 8.05 secs	time: 6.73 secs	time: $>3$ hours
F16-31-7.cnf	res: $[2^{14.5},2^{18.5}]$	res: $[2^{14.5},2^{18.5}]$	res: $[2^{13.86},2^{17.85}]$
	time: 11.75 secs	time: 9.5 secs	time: 22 mins 43 secs
F11-31-9.cnf	res: $[2^{9.5},2^{13.5}]$	res: $[2^{9.5},2^{13.5}]$	res: $[2^{9.09},2^{13.09}]$
	time: 6.75 secs	time: 4.32 secs	time: 15.24 secs
F6-31-11.cnf	res: $[2^{4.5},2^{8.5}]$	res: $[2^{4.5},2^{8.5}]$	res: $[2^4,2^8]$
	time: 3.01 secs	time: 2.62 secs	time: 1.9 secs
F16-63-23.cnf	res: $[2^{14.5},2^{18.5}]$	res: $[2^{14.5},2^{18.5}]$	res: $[2^{13.9},2^{17.9}]$
	time: 31 mins 15 secs	time: 2 min 36 secs	time: 54 mins 57 secs

Equations

$$\mathrm{Pr}(Err)$$

$$p$$

$$\le$$

$$\mathrm{Pr}(Err)$$

$$|I_0|$$

$$\begin{array}[]{rl}|I_{k}|\leq&\left\{\begin{array}[]{ll}\frac{u_{k-1}-l_{k-1}}{2}+\alpha+\frac{1}{2}&\mbox{ if }A(s_{k},m)=1\mbox{ and }s_{k}=\left\lfloor\frac{u_{k-1}-l_{k-1}}{2}\right\rfloor\vspace*{.2cm}\\ \frac{u_{k-1}-l_{k-1}}{2}+\beta&\mbox{ if }A(s_{k},m)=0\mbox{ and }s_{k}=\left\lfloor\frac{u_{k-1}-l_{k-1}}{2}\right\rfloor\vspace*{.2cm}\\ \frac{u_{k-1}-l_{k-1}}{2}+\alpha&\mbox{ if }A(s_{k},m)=1\mbox{ and }s_{k}=\left\lceil\frac{u_{k-1}-l_{k-1}}{2}\right\rceil\vspace*{.2cm}\\ \frac{u_{k-1}-l_{k-1}}{2}+\beta+\frac{1}{2}&\mbox{ if }A(s_{k},m)=0\mbox{ and }s_{k}=\left\lceil\frac{u_{k-1}-l_{k-1}}{2}\right\rceil\end{array}\right.\end{array}$$

$$|I_k|$$

$$|I_{\lceil {\log }_{2}m\rceil }|$$

$$\sum _{k=1}^{\lceil {\log }_{2}m\rceil }\mathrm{Pr}(O{K}_1)\dots \mathrm{Pr}(O{K}_{k-1})\mathrm{Pr}(ER{R}_k)=\sum _{k=1}^{\lceil {\log }_{2}m\rceil }(1-\delta {)}^{k-1}\delta \le \lceil {\log }_{2}m\rceil \delta$$

$$a_0$$

$$\mathrm{Pr}(a_0,a_1,...,a_m)$$

$$p(1)=p(0)=\frac{1}{2}{p}^{\prime }(1)=\lambda p^{\prime }(0)=1-\lambda$$

$${\chi }_s\stackrel{△}{=}\varphi \wedge c_1\wedge \cdots \wedge c_s$$

$$\mathrm{Pr}(Y_{\sigma }=1,Y_{{\sigma }^{\prime }}=1|a_0=0)=$$

$$=\mathrm{Pr}(\text{ ∣C∩U∣,∣C∩I∣, ∣C∩V∣ are even})$$

$$+\mathrm{Pr}(\text{∣C∩U∣,∣C∩I∣, ∣C∩V∣ are odd})$$

$$=U_e\cdot I_e\cdot V_e+U_o\cdot I_o\cdot V_o$$

$$\mathrm{Pr}(Y_{\sigma }=1,Y_{{\sigma }^{\prime }}=1|a_0=1)$$

$$=\mathrm{Pr}(\text{∣C∩I∣ is even, ∣C∩U∣,∣C∩I∣ are odd})$$

$$+\mathrm{Pr}(\text{∣C∩I∣ is odd, ∣C∩U∣,∣C∩I∣ are even})$$

$$=U_o\cdot I_e\cdot V_o+U_e\cdot I_o\cdot V_e$$

$$=U_o\cdot (1-I_o)\cdot V_o+U_e\cdot (1-I_e)\cdot V_e$$

$$=U_o\cdot V_o+U_e\cdot V_e-U_o\cdot I_o\cdot V_o-U_e\cdot I_e\cdot V_e$$

$$\mathrm{Pr}(Y_{\sigma }=1,Y_{{\sigma }^{\prime }}=1)$$

$$U_e=\frac{1}{2}(1+{\rho }^{|U|})V_e=\frac{1}{2}(1+{\rho }^{|V|})$$

$$\mathrm{Pr}(Y_{\sigma }=1,Y_{{\sigma }^{\prime }}=1)$$

$$T_s$$

$$\mathrm{Pr}\left(A(s,\varphi )=0\right)$$

$$\mathrm{Pr}\left(A(s,\varphi )=1\right)$$

$$T^2$$

$$E[T^2]$$

$$S$$

$$L_j^{\sigma }(\Sigma )\stackrel{△}{=}\{|{\Delta }_{{\sigma }^{\prime }}\cap {\Delta }_{{\sigma }^{\prime \prime }}|:\{{\sigma }^{\prime },{\sigma }^{\prime \prime }\}\subseteq \Sigma \wedge |{\Delta }_{{\sigma }^{\prime }}|=|{\Delta }_{{\sigma }^{\prime \prime }}|=j\}$$

$$L_{j}^{\sigma}(\Sigma)=\left\{\begin{array}[]{ll}\{0,\ldots,j-\left\lceil\frac{d}{2}\right\rceil\}&\mbox{ if }j\leq\frac{m}{2}\vspace*{.2cm}\\ \{2j-m,\ldots,j-\left\lceil\frac{d}{2}\right\rceil\}&\mbox{otherwise.}\end{array}\right.$$

Full text

1 Introduction

#SAT (aka model-counting) is the problem of counting the number of satisfying assignments of a given Boolean formula and is a #P-complete problem. Indeed, every NP Turing machine can be encoded as a formula whose satisfying assignments correspond to the accepting paths of the machine [26]. Thus, model-counting is harder than satisfiability: #SAT is indeed intractable in cases for which SAT is tractable (e.g., sets of Horn clauses or sets of 2-literal clauses) [27]. Still, there are cases in which model-counting is tractable (e.g., OBDDs and d-DNNFs). For a very good overview of the problem and of some approaches to it see [14].

Our interest in model counting originates from its applications in the field of Quantitative Information Flow (qif) [8, 22]. Indeed, a basic result in qif is that the maximum min-entropy leakage of a deterministic program is $\log_{2}k$, with $k$ the number of distinct outputs the program can return [22], varying the input. If the program is modeled as a Boolean formula, then computing its leakage reduces to #SAT, specifically to computing the number of models of the formula obtained by existentially projecting out the non-output variables; see [4, 17].

Over the years, several exact counting algorithms have been put forward and implemented, such as, among others, [12, 17, 20, 25], with applications to qif [16]. The problem with exact counters is that, although performing reasonably well when certain parameters of the formula – size, number of variables, number of clauses – are relatively small, they rapidly go out of memory as these parameters grow.

For this reason, approximate counters have more and more been considered. Indeed, in many applications, the exact count of models is not required: it may suffice to provide an estimate, as long as the method is quick and it is equipped with a formal guarantee of correctness. This is typically the case in qif, where knowing the exact count within a factor of $\eta$ is sufficient to estimate leakage within $\log_{2}\eta$ bits. For probabilistic counters, correctness is usually expressed in terms of two parameters: accuracy – the desired maximum difference between the reported and the true count; and confidence – the probability that the reported result is actually within the specified accuracy.

We set ourselves in the line of research pioneered by [27] and followed, e.g., by [2, 13, 6, 17]. The basic idea of a probabilistic model counting algorithm is the following (Section 2): given a formula $\phi$ in the Boolean variables $y_{1},\ldots,y_{m}$, one chooses at random $\langle a_{0},\ldots,a_{m}\rangle\in\{0,1\}^{m+1}$. The resulting XOR constraint $a_{0}=a_{1}y_{1}\oplus\cdots\oplus a_{m}y_{m}$ splits evenly the set of models of $\phi$ into two parts: those satisfying the constraint and those not satisfying it. If one independently generates $s$ such constraints $c_{1},\ldots,c_{s}$, the formula $\phi^{\prime}\stackrel{{\scriptstyle\triangle}}{{=}}\phi\wedge c_{1}\wedge\cdots\wedge c_{s}$ has an expected $\frac{N}{2^{s}}$ models, where $N$ is the number of models of $\phi$ (i.e., the number we aim at estimating). If $\phi^{\prime}$ is still satisfiable, then with high probability $N\geq 2^{s}$, otherwise $N<2^{s}$. By repeating this process, one can arrive at a good estimate of $N$. This procedure can be implemented by relying on any SAT-solver capable of dealing with XOR constraints, e.g CryptoMiniSat [24]; or even converting the XOR constraints into CNF before feeding $\phi^{\prime}$ to the SAT solver. In any case, the branching factor associated with searching for models of $\phi^{\prime}$ quickly explodes as the length (number of variables) of the XOR constraints grows. The random generation outlined above will lead to an expected length of $\frac{m}{2}$ for each constraint, making the procedure not easily scalable as $m$ grows.

In the present paper, we study under what conditions one can employ sparse, hence shorter, constraints, keeping the same guarantees of correctness. We generalize the results of [9] to arrive at an improved understanding of how sparsity is related to minimum distance between models, and how this affects the counting procedure. Based on these results, we also suggest a possible direction for a new counting methodology based on the use of Low Density Parity Check (LDPC) codes [11, 19]; however, we leave a through experimentation with this new methodology for future work.

The main point is to generate the coefficients $a_{1},\ldots,a_{m}$ according to a probability value $\lambda\in\left(0,\frac{1}{2}\right]$, rather than uniformly. This way, the constraints will have an average length of $\lambda m\ \leq\frac{m}{2}$ each. Basically, the correctness guarantees of the algorithm depend, via the Chebyshev inequality, on keeping the variance of the number of models of $\phi^{\prime}$, the formula obtained by joining the constraints, below a certain threshold. A value of the density $\lambda$ that achieves this is said to be feasible for the formula. In our main result (Section 3), we provide a bound on the variance that also depends on the minimum Hamming distance $d$ between the formula’s models: a larger $d$ yields a smaller variance, hence smaller feasible $\lambda$’s. Our bound essentially coincides with that of [9] for $d=1$. Therefore, in principle, a lower bound on the minimum distance can be used to obtain tighter bounds on $\lambda$, making the XOR constraints shorter and the counting procedure pragmatically more efficient.

We will show this phenomenon at work (Section 4) on some formulae where the value of $d$ is known by construction, comparing our results with the state of the art model counter ApproxMC3 [23]. These considerations also suggest that, if no information on $d$ is available, one can encode the formula’s models using an error correcting code with a known minimum distance. We will briefly discuss the use of LDPC codes to this purpose, although at the moment we have no experimental results available in this respect. A comparison with recent related work concludes the paper (Section 5).

2 A general counting algorithm

In what follows, we let $\phi(y)$, or just $\phi$, denote a generic boolean formula with boolean variables $y=(y_{1},...,y_{m})$ and $m\geq 1$.

2.1 A general scheme

According to a well-known general scheme [13], the building block of a statistical counting procedure is a probabilistic decision algorithm: with high probability, this algorithm correctly decides whether the cardinality of the set is, or is not, below a given threshold $2^{s}$, within some tolerance factors, given by the slack parameters $\alpha$ and $\beta$ below.

Definition 2.1** (#SAT decision algorithm)**

Let $0\leq\delta<frac12$ (error probability), $\alpha>1$ and $\beta>1$ (two slack parameters) be three reals. An $(\alpha,\beta,\delta)$-decision algorithm (for #SAT) is a probabilistic algorithm $A(\cdot,\cdot)$, taking a pair of an integer $s$ and a boolean formula $\phi$, and returning either $1$ (meaning ‘$\#\phi\geq 2^{s-\alpha}$’) or [math] (meaning ‘$\#\phi\leq 2^{s+\beta}$’) and such that for each integer $s\geq 0$ and formula $\phi$:

$\#\phi>2^{s+\beta}$* implies $\Pr\left(A(s,\phi)=0\right)\leq\delta$;* 2. 2.

$\#\phi<2^{s-\alpha}$* implies $\Pr\left(A(s,\phi)=1\right)\leq\delta$.*

The use of two different slack parameters in the definition above is justified by the need of stating formal guarantees about the outcome of the algorithm, while keeping the precision of the algorithm as high as possible.

As usual, we can boost the confidence in the reported answer, and get an arbitrarily small error probability, by running $A(s,\phi)$ several times independently. In particular, consider the algorithm $RA_{t}(s,\phi)$ obtained by running $A(s,\phi)$ an odd $t\geq 1$ number times independently, and then reporting the majority answer. Call $Err$ the event that $RA_{t}$ reports a wrong answer; then,

[TABLE]

where

[TABLE]

Now, replacing (5) in (1), we obtain

[TABLE]

Let us call $\Delta(t,\delta)$ the right hand side of (6); then, $RA_{t}$ is an $(\alpha,\beta,\Delta(t,\delta))$-decision algorithm whenever $A$ is an $(\alpha,\beta,\delta)$-decision algorithm.

We now show that any $(\alpha,\beta,\delta)$-decision algorithm $A$ for #SAT can be used as a building block for a counting algorithm, $C_{A}(\phi)$, that determines an interval $[\ell,u]$ such that $\lfloor 2^{\ell}\rfloor\leq\#\phi\leq\lceil 2^{u}\rceil$ with high probability. Informally, starting with an initial interval $[-1,m]$, the algorithm $C_{A}$ performs a binary search, using $A$ to decide which half of the current interval $\log_{2}(\#\phi)$ lies in. The search stops when the current interval cannot be further narrowed, taking into account the slack parameters $\alpha$ and $\beta$, or when a certain predefined number of iterations is reached. Formally, let $I_{0}\stackrel{{\scriptstyle\triangle}}{{=}}[-1,m]$. Assume $k>0$ and $I_{k}=[l_{k},u_{k}]$, then:

• (a)

if $u_{k}-l_{k}\leq 2\max(\alpha,\beta)+1$ or $k=\lceil\log_{2}(m)\rceil$, then return $I_{k}$;

• (b)

otherwise, let $s=\mathit{round}\!\left(\frac{u_{k}+l_{k}}{2}\right)$; if $A(s,\phi)=0$ then $I_{k+1}\stackrel{{\scriptstyle\triangle}}{{=}}[l_{k},s+\beta]$ otherwise $I_{k+1}\stackrel{{\scriptstyle\triangle}}{{=}}[s-\alpha,u_{k}]$.

Theorem 2.2

Let $A$ be a $(\alpha,\beta,\delta)$-decision algorithm. Then:

$C_{A}(\phi)$* terminates in $k\leq\lceil\log_{2}m\rceil$ iterations returning an interval $I_{k}=[l,u]$ such that $u-l\leq 2\max(\alpha,\beta)+2$;* 2. 2.

The probability that $\#\phi\notin[\lfloor 2^{l}\rfloor,\lceil 2^{u}\rceil]$ is at most $\lceil\log_{2}m\rceil\delta$.

• Proof: If the algorithm terminates because $u_{k}-l_{k}\leq 2\max(\alpha,\beta)+1$, the first claim is trivial. Otherwise, by construction of the algorithm, we have that

[TABLE]

Furthermore, by passing from $I_{k-1}$ to $I_{k}$, we have that $s_{k}=round\!\left(\frac{u_{k-1}+l_{k-1}}{2}\right)$ and

[TABLE]

since, by definition of $round$, $\frac{u_{k-1}+l_{k-1}}{2}-\frac{1}{2}<s_{k}\leq\frac{u_{k-1}+l_{k-1}}{2}$, if $s_{k}=\left\lfloor\frac{u_{k-1}+l_{k-1}}{2}\right\rfloor$, and $\frac{u_{k-1}+l_{k-1}}{2}\leq s_{k}<\frac{u_{k-1}+l_{k-1}}{2}+\frac{1}{2}$, if $s_{k}=\left\lceil\frac{u_{k-1}+l_{k-1}}{2}\right\rceil$. Thus, by letting $M=\max(\alpha,\beta)+\frac{1}{2}$, we have:

[TABLE]

If we now unfold (8) and use (7), we obtain that

[TABLE]

By now considering $k=\lceil\log_{2}m\rceil$ in (9), we obtain that

[TABLE]

being $\log_{2}m\leq\lceil\log_{2}m\rceil\leq\log_{2}m+1$ and $M>1$.

The error probability is the probability that either $\#\phi<\lfloor 2^{l}\rfloor$ or $\#\phi>2^{u}$. This is the probability that one of the $\lceil\log_{2}m\rceil$ calls to $A$ has returned a wrong answer, that can be calculated as follows:

[TABLE]

where $\Pr(OK_{i})$/$\Pr(ERR_{i})$ denotes the probability that the $i$-th iteration returned a correct/wrong answer, respectively.

In all the experiments we have run, the algorithm has always returned an interval of width at most $2\max(\alpha,\beta)+1$, sometimes in less than $\lceil\log_{2}(m)\rceil$ iterations: this consideration pragmatically justifies the exit condition we used in the algorithm. We leave for future work a more elaborated analysis of the algorithm to formally establish the $2\max(\alpha,\beta)+1$ bound.

2.2 XOR-based decision algorithms

Recall that a XOR constraint $c$ on the variables $y_{1},...,y_{m}$ is an equality of the form

[TABLE]

where $a_{i}\in\mathbb{F}_{2}$ for $i=0,...,m$ (here $\mathbb{F}_{2}=\{0,1\}$ is the two elements field.) Hence $c$ can be identified with a $(m+1)$-tuple in $\mathbb{F}^{m+1}_{2}$. Assume that a probability distribution on $\mathbb{F}^{m+1}_{2}$ is fixed. A simple proposal for a decision algorithm $A(s,\phi)$ is as follows:

generate $s$ XOR constraints $c_{1},\ldots,c_{s}$ independently, according to the fixed probability distribution; 2. 2.

if $\phi\wedge c_{1}\wedge\cdots\wedge c_{s}$ is unsatisfiable then return 0, else return 1.

Indeed [13], every XOR constraint splits the set of boolean assignments in two parts, according to whether the assignment satisfies the constraint or not. Thus, if $\phi$ has less than $2^{s}$ models (and so less than $2^{s+\beta}$), the formula $\phi\wedge c_{1}\wedge\cdots\wedge c_{s}$ is likely to be unsatisfiable.

In step 2 above, any off-the-shelf SAT solver can be employed: one appealing possibility is using CryptoMiniSat [24], which offers support for specifying XOR constraints (see e.g. [4, 6, 17]). Similarly to [13], it can be proved that this algorithm yields indeed an $(\alpha,\beta,\delta)$-decision algorithm, for a suitable $\delta<\frac{1}{2}$, if the constraints $c_{i}$ at step 1 are chosen uniformly at random. This however will generate ‘long’ constraints, with an average of $\frac{m}{2}$ variables each, which a SAT solver will not be able to manage as $m$ grows.

3 Counting with sparse XORs

We want to explore alternative ways of generating constraints, which will make it possible to work with short (‘sparse’) XOR constraints, while keeping the same guarantees of correctness. In what follows, we assume a probability distribution over the constraints, where each coefficient $a_{i}$, for $i>0$, is chosen independently with probability $\lambda$, while $a_{0}$ is chosen uniformly (and independently from all the other $a_{i}$’s). In other words, we assume that the probability distribution over $\mathbb{F}^{m+1}_{2}$ is of the following form, for $\lambda\in\left(0,\frac{1}{2}\right]$:

[TABLE]

The expected number of variables appearing in a constraint chosen according to this distribution will therefore be $m\lambda$. Let us still call $A$ the algorithm presented in Section 2.2, with this strategy in choosing the constraints. We want to establish conditions on $\lambda$ under which $A$ can be proved to be a decision algorithm.

Throughout this section, we fix a boolean formula $\phi(y_{1},...,y_{m})$ and $s\geq 1$ XOR constraints. Let

[TABLE]

where the $c_{i}$ are chosen independently according to (10). For any assignment (model) $\sigma$ from variables $y_{1},...,y_{m}$ to $\mathbb{F}_{2}$, let us denote by $Y_{\sigma}$ the Bernoulli r.v. which is $1$ iff $\sigma$ satisfies $\chi_{s}$.

We now list the steps needed for proving that $A$ is a decision algorithm. This latter result is obtained by Proposition 3.2(2) (that derives from Lemma 3.1(1)) and by combining Proposition 3.2(1), Lemma 3.4(3) (that derives from Lemma 3.1(2)) and Lemma 3.7 in Theorem 3.9 later on. In what follows, we shall let $\rho\stackrel{{\scriptstyle\triangle}}{{=}}1-2\lambda$.

Lemma 3.1

$\Pr(Y_{\sigma}=1)=E[Y_{\sigma}]=2^{-s}$. 2. 2.

Let $\sigma,\sigma^{\prime}$ be any two assignments and $d$ be their Hamming distance in $\mathbb{F}_{2}^{m}$ (i.e., the size of their symmetric difference seen as subsets of $\{1,...,m\}$). Then $\Pr(Y_{\sigma}=1,Y_{\sigma^{\prime}}=1)=E[Y_{\sigma}\cdot Y_{\sigma^{\prime}}]=\left(\frac{1+\rho^{d}}{4}\right)^{s}$ (where we let $\rho^{d}\stackrel{{\scriptstyle\triangle}}{{=}}1$ whenever $\rho=d=0$.)

• Proof: Concerning the first item, note that the probability that $\sigma$ satisfies any constraint chosen according to (10) is $\frac{1}{2}$, because the parity bit $a_{0}$ is chosen uniformly at random; consequently, the probability that $\sigma$ satisfies the $s$ constraints $c_{1},\ldots,c_{s}$ chosen independently is $\frac{1}{2^{s}}$.

Let us examine the second item. We first consider the case of $s=1$ constraint. Let $A$ and $B$ be the sets of variables that are assigned the value 1 in $\sigma$ and $\sigma^{\prime}$, respectively. We let $U=A\setminus B$, $V=B\setminus A$ and $I=A\cap B$. Note that by definition $d=|U\cup V|=|U|+|V|$. Let $C$ be the set of variables appearing in the constraint $c_{1}$. Assume first that the constraint’s parity bit $a_{0}$ is [math], which happens with probability $\frac{1}{2}$. Given this event, both $\sigma$ and $\sigma^{\prime}$ satisfy the constraint if and only if both $|C\cap A|$ and $|C\cap B|$ are even. This is in turn equivalent to (all of $|C\cap U|,|C\cap I|$, $|C\cap V|$ are even) or (all of $|C\cap U|,|C\cap I|$, $|C\cap V|$ are odd). Moreover these two events are clearly disjoint. Since the three sets of variables $U,I,V$ are pairwise disjoint, and since according to (10) the constraint’s variables are chosen independently, we can compute as follows. Here, $U_{e}$ and $U_{o}$ abbreviate $\Pr(|C\cap U|\text{ is even})$ and $\Pr(|C\cap U|\text{ is odd})$, respectively; similarly for $I_{e},I_{o}$ and $V_{e},V_{o}$.

[TABLE]

Reasoning similarly, we obtain

[TABLE]

By using (11) and (12), we can compute

[TABLE]

Now, it is a standard result (see e.g. [1]) that, given $t$ independent trials of a Bernoulli variable of parameter $\lambda\leq\frac{1}{2}$, the probability of obtaining an even number of 1 is $\frac{1}{2}(1+(1-2\lambda)^{t})$. Recalling that we have posed $\rho=1-2\lambda$, and replacing $t$ with $|U|$ or $|V|$, we therefore have

[TABLE]

Plugging the above two equations into (13), with some algebra we get

[TABLE]

This completes proof that the probability that both $\sigma$ and $\sigma^{\prime}$ survive $s=1$ constraint is $\frac{1}{4}(1+\rho^{d})$. The general case of $s\geq 1$ independent constraints is immediate.

Now let $T_{s}$ be the random variable that counts the number of models of $\chi_{s}$, when the constraints $c_{1},...,c_{s}$ are chosen independently according to distribution (10):

[TABLE]

The event that $\chi_{s}$ is unsatisfiable can be expressed as $T_{s}=0$. A first step toward establishing conditions under which $A$ yields a decision algorithm is the following result. It makes it clear that a possible strategy is to keep under control the variance of $T_{s}$, which depends in turn on $\lambda$. Let us denote by $\mu_{s}$ the expectation of $T_{s}$ and by $\mathrm{var}(T_{s})$ its variance. Note that $\mathrm{var}(T_{s})>0$ if $\#\phi>0$.

Proposition 3.2

$\#\phi>2^{s+\beta}$* implies $\Pr\left(A(s,\phi)=0\right)\leq\frac{1}{1+\frac{\mu_{s}^{2}}{\mathrm{var}(T_{s})}}$;* 2. 2.

$\#\phi<2^{s-\alpha}$* implies $\Pr\left(A(s,\phi)=1\right)<2^{-\alpha}$.*

• Proof: For part 1,

[TABLE]

where the last but one step is a version of the Cantelli-Chebyshev inequality for integer nonnegative random variables (see e.g. [18, Ch.2, Ex.2], aka Alon-Spencer’s inequality.)

For part 2, first recall from [13] that $\mu=\frac{\#\phi}{2^{s}}$ (this can be obtained by Lemma 3.1(1) and by observing that $T=\sum_{\sigma}Y_{\sigma}$: indeed, $\mu=E[T]=E[\sum_{\sigma}Y_{\sigma}]=\sum_{\sigma}E[Y_{\sigma}]=\sum_{\sigma}2^{-s}=\frac{\#\phi}{2^{s}}$). To conclude,

[TABLE]

where the last but one step is Markov’s inequality and the last one follows by noting that $\frac{\#\phi}{2^{s}}<2^{-\alpha}$ under the given hypothesis.

By the previous proposition, assuming $\alpha>1$, we obtain a decision algorithm (Definition 2.1) provided that $\mathrm{var}(T_{s})<\mu_{s}^{2}$. This will depend on the value of $\lambda$ that is chosen, which leads to the following definition.

Definition 3.3** (feasibility)**

Let $\phi$, $s$ and $\beta$ be given. A value $\lambda\in\left(0,\frac{1}{2}\right]$ is said to be $(\phi,s,\beta)$-feasible if $\#\phi>2^{s+\beta}$ implies $\mathrm{var}(T_{s})<\mu_{s}^{2}$, where the constraints in $\chi_{s}$ are chosen according to (10).

Our goal is now to give a method to minimize $\lambda$ while preserving feasibility. Recall that $T_{s}\stackrel{{\scriptstyle\triangle}}{{=}}\#\chi_{s}$. Denote by $\sigma_{1},...,\sigma_{N}$ the distinct models of $\phi$ (hence, $T_{s}\leq N$). Note that $T_{s}=\sum_{i=1}^{N}Y_{\sigma_{i}}$. Given any two models $\sigma_{i}$ and $\sigma_{j}$, $1\leq i,j\leq N$, let $d_{ij}$ denote their Hamming distance. The following lemma gives exact formulae for the expected value and variance of $T_{s}$.

Lemma 3.4

Let $\rho=1-2\lambda$.

$\mu_{s}=E[T_{s}]=N2^{-s}$; 2. 2.

$\mathrm{var}(T_{s})=\mu_{s}+4^{-s}\sum_{i=1}^{N}\sum_{j\neq i}({1+\rho^{d_{ij}}})^{s}-\mu^{2}_{s}$; 3. 3.

If $N\neq 0$, then $\frac{\mathrm{var}(T_{s})}{\mu^{2}}=\mu^{-1}_{s}+N^{-2}\sum_{i=1}^{N}\sum_{j\neq i}({1+\rho^{d_{ij}}})^{s}-1$

• Proof: The first item is obvious from Lemma 3.1(1), $T=\sum_{i=1}^{N}Y_{\sigma_{i}}$ and linearity of expectation.

Concerning the second item, recall that $\mathrm{var}(T)=E[T^{2}]-\mu^{2}$. Now, taking into account that $Y_{\sigma}\cdot Y_{\sigma}=Y_{\sigma}$, we have

[TABLE]

Applying expectation to both sides of the above equation, then exploiting linearity and Lemma 3.1(2)

[TABLE]

Since $\mu^{2}=(\frac{N}{2^{s}})^{2}$, the thesis for this part easily follows.

The third item is an immediate consequence of the first two.

Looking at the third item above, we clearly see that the upper bound on the error probability we are after depends much on ‘how sparse’ the set of $\phi$’s models is in the Hamming space $\mathbb{F}_{2}^{m}$: the sparser, the greater the distance, the lower the value of the double summation, the better. Let us denote by $S$ the double summation in the third item of the above lemma:

[TABLE]

In what follows, we will give an upper bound on $S$ which is easy to compute and depends on the minimum Hamming distance $d$ among any two models of $\phi$. We need some notation about models of a formula. To this aim, we need a preliminary lemma.

Lemma 3.5

Let $\Sigma\subseteq\{0,1\}^{m}$ be such that the minimum Hamming distance between two strings in $\Sigma$ is $d$. Fix $\sigma\in\Sigma$. For every $\sigma^{\prime}\in\Sigma$, let $\Delta_{\sigma^{\prime}}=\{i\in\{1,...,m\}:\sigma^{\prime}(i)\neq\sigma(j)\}$ the set of positions where $\sigma^{\prime}$ differs from $\sigma$. For every $j=d,...,m$, let us define the set of integers

[TABLE]

Then

[TABLE]

• Proof: Let us first consider how many elements can at most $\Delta_{\sigma^{\prime}}$ and $\Delta_{\sigma^{\prime\prime}}$ have in common. Independently of the value of $j$, since $\sigma^{\prime}$ and $\sigma^{\prime\prime}$ must differ for at least $d$ positions, $\Delta_{\sigma^{\prime}}$ and $\Delta_{\sigma^{\prime\prime}}$ can share at most $j-\left\lceil\frac{d}{2}\right\rceil$ elements.

Let us now consider the least number of elements that $\Delta_{\sigma^{\prime}}$ and $\Delta_{\sigma^{\prime\prime}}$ can have in common. We start by considering $j\leq\frac{m}{2}$ (notice that, if $j=\frac{m}{2}$, then $m$ must be even). In this case, it is possible that $\Delta_{\sigma^{\prime}}\cap\Delta_{\sigma^{\prime\prime}}=\emptyset$, (e.g., by having all elements of $\Delta_{\sigma^{\prime}}$ in the first $\left\lfloor\frac{m}{2}\right\rfloor$ bits and all elements of $\Delta_{\sigma^{\prime\prime}}$ in the last $\left\lfloor\frac{m}{2}\right\rfloor$ bits). Let $j>\frac{m}{2}$. In this case, $\Delta_{\sigma^{\prime}}$ and $\Delta_{\sigma^{\prime\prime}}$ must intersect (since $2j>m$) and the minimum value for the size of their intersection is $2j-m$.

Below, we let $j=d,...,m$.

[TABLE]

where we stipulate that $\min\emptyset=0$. Note that the definitions of $w^{*}$ and $N^{*}$ depend solely on $N,m$ and $d$.

As another ingredient of the proof, we need the following lemma from extremal set theory; for a proof, see [3, Th.4.2].

Lemma 3.6** (Ray-Chaudhuri-Wilson)**

Let $\mathcal{F}$ be a family of subsets of $\{1,...,m\}$, all of the same size $k$. Let $L$ be a set of nonnegative integers such that $|L|\leq k$ and for every pair of distinct $A,B\in\mathcal{F}$, $|A\cap B|\in L$. Then $|\mathcal{F}|\leq{m\choose{|L|}}$.

With the above definitions and results, we have the following upper bound on $S$.

Lemma 3.7

Let the minimal distance between any two models of $\phi$ be at least $d$. Then

[TABLE]

• Proof: Fix one of the models of $\phi$ (say $\sigma_{i}$), and consider the sub-summation originated by it, $S_{i}\stackrel{{\scriptstyle\triangle}}{{=}}\sum_{j\neq i}\left(\frac{1+\rho^{d_{ij}}}{4}\right)^{s}$. Let us group the remaining $N-1$ models into disjoint families, $\mathcal{F}_{d},\mathcal{F}_{d+1},\ldots$, of models that are at distance $d,d+1,...$, respectively, from $\sigma_{i}$. Note that each of the $N-1$ models gives rise to exactly one term in the summation $S_{i}$. Hence,

[TABLE]

We now want to upper-bound this sum.

To this aim, notice that, for every $\{\sigma^{\prime},\sigma^{\prime\prime}\}\subseteq\mathcal{F}_{j}$. by definition $|\Delta_{\sigma^{\prime}}\cap\Delta_{\sigma^{\prime\prime}}|\in L_{j}^{\sigma_{i}}(\Sigma)$. Now, we can identify each model $\sigma$ with $\Delta_{\sigma}$, its symmetric difference from $\sigma_{i}$, seen as a subset of $\{1,...,m\}$. Then, by definition, each set in $\mathcal{F}_{j}$ has cardinality $j$ and, by Lemma 3.5 (where $\sigma_{i}$ plays the role of $\sigma$) and by Lemma 3.6, we have that $|\mathcal{F}_{j}|\leq{m\choose{l_{j}}}$. Hence, upper-bounding (20)111 Notice that we are not trying to upper bound every summand of (20), but just the overall sum. consists, e.g., in choosing a tuple of integers $x_{d},\ldots,x_{m}$ in such a way that function

[TABLE]

is greater than or equal to the r.h.s. of (20), under the constraints

[TABLE]

Since $0\leq\rho<1$, we obtain an upper-bound by maximizing the $x_{j}$’s for which $j$ is closer to $d$. Hence, the optimal solution of the linear programming problem with (21) as objective function and (22) as constraints is

[TABLE]

with the definitions of $w^{*}$ and $N^{*}$ given in (17) and (18), respectively.

All together, these facts imply that

[TABLE]

By summing the above inequality over all models $\sigma_{i}$, we obtain the thesis.

Definition 3.8

Given $s\geq 1$, $\beta>0$, $d\geq 1$ and $\lambda\in\left(0,\frac{1}{2}\right]$, let us define

[TABLE]

​​where $\rho\stackrel{{\scriptstyle\triangle}}{{=}}1-2\lambda$ and $N=\lceil 2^{s+\beta}\rceil$ also in the definition of $w^{*}$ and $N^{*}$.

Using the facts collected so far, the following theorem follows, giving an upper bound on $\frac{\mathrm{var}(T_{s})}{\mu^{2}_{s}}$.

Theorem 3.9** (upper bound)**

*Let the minimal distance between models of $\phi$ be at least $d$ and $\#\phi>2^{s+\beta}$. Then, $\frac{\mathrm{var}(T_{s})}{\mu^{2}_{s}}\leq B(s,m,\beta,d,\lambda)$. *

• Proof: First note that we can assume without loss of generality that $\#\phi=N=\lceil 2^{s+\beta}\rceil$. If this was not the case, we can consider in what follows any formula $\phi^{\prime}$ whose models are models of $\phi$ but are exactly $\lceil 2^{s+\beta}\rceil$ ($\phi^{\prime}$ can be obtained by adding some conjuncts to $\phi$ that exclude $\#\phi-\lceil 2^{s+\beta}\rceil$ models). Then, $\Pr\left(A(s,\phi)=0\right)\leq\Pr\left(A(s,\phi^{\prime})=0\right)$ and this would suffice, for the purpose of upper-bounding $\Pr\left(A(s,\phi)=0\right)$.

Then, by Lemma 3.4(3) (first step), by Lemma 3.7 (second step) and by the fact that $N=\lceil 2^{s+\beta}\rceil\geq 2^{s+\beta}$ (fourth step), we have :

[TABLE]

The result follows from Proposition 3.2(1).

The following notation will be useful in the rest of the paper. For $0\leq\gamma\leq 1$, define

[TABLE]

where we stipulate $\inf\emptyset=+\infty$.

Corollary 3.10** (Feasibility)**

Assume the minimal distance between any two models of $\phi$ is at least $d$. Then every $\lambda\in\left(\lambda^{*}_{1}(s,m,\beta,d),\frac{1}{2}\right]$ is $(\phi,s,\beta)$-feasible.

• Proof: Since $B(s,m,\beta,d,\lambda)$ is a decreasing function of $\lambda$, whenever it exists the value $\lambda$ s.t. $B(s,m,\beta,d,\lambda)=1$ it is unique. If $\lambda^{*}\neq+\infty$, since $B(s,m,\beta,d,\lambda)$ is an upper bound of $\frac{\mathrm{var}(T)}{\mu^{2}}$, any value $\lambda$ such that $\frac{1}{2}\geq\lambda>\lambda^{*}(s,m,\beta,d)$ is feasible and therefore can be used to make algorithm $A$ work (see Theorem 3.9). If $\lambda^{*}=+\infty$, we note that $\lambda=\frac{1}{2}$ is feasible:

[TABLE]

where the first step comes from Lemma 3.4(3) and (19) (with $\lambda=\frac{1}{2}$) and the third one holds by hypothesis.

4 Evaluation

4.1 Theoretical bounds on expected constraint length

To assess the improvements that our theory introduces on XOR-based approximate counting, we start by considering the impact of minimum Hamming distance on the expected length of the XOR constraints. First, in Fig. 1 we plot $\lambda^{*}_{1}$ as a function of $s$, for fixed values of $m=32$ and $64$, $\beta=1.5$, and four different values of $d$. Note that the difference between different values of $d$ tends to vanish as $s$ gets large – i.e. close to $m$.

Next, we compare our theoretical bounds with those in [9], where a goal similar to ours is pursued. Interestingly, their bounds coincide with ours when setting $d=1$ – no assumption on the minimum Hamming distance – showing that our approach generalizes theirs. We report a numerical comparison in Table 1, where several hypothetical values of $m$ (no. of variables) and $s$ (no. of constraints) are considered. Following a similar evaluation conducted in [9, Tab.1], here we fix the error probability to $\delta=\frac{4}{9}$ and the upper slack parameter to $\beta=2$, and report the values of $\lambda\times m$ for the minimal value of $\lambda$ that would guarantee a confidence of at least $1-\delta$ in case an upper bound is found, computed with their approach and ours. Specifically, in their case $\lambda$ is obtained via the formulae in [9, Cor.1,Th.3], while in our case $\lambda=\lambda^{*}_{\gamma}$ for $\gamma=0.8$, which entails the wanted confidence according to Proposition 3.2(2). We see that, under the assumption that lower bounds on $d$ as illustrated are known, in some cases a dramatic reduction of the expected length of the XOR constraints is obtained.

4.2 Execution times

Although the focus of the present paper is mostly theoretical, it is instructive to look at the results of some simple experiments for a first concrete assessment of the proposed methodology. To this aim, we have implemented in Python the algorithm $C_{A}$ with $A$ as described in Section 3, relying on CryptoMiniSAT [24] as a SAT solver, and conducted a few experiments222Run on a MacBook Air, with a 1,7 GHz Intel Core i7 processor, 8 GB of memory (1600 MHz DDR3) and OS X 10.9.5..

The crucial issue to use Theorem 3.9 is the knowledge of (a lower bound on) the minimal distance $d$ among the models of the formula we are inputting to our algorithm. In general, this information is unknown and we shall discuss a possible approach to face this problem in the next section. For the moment, we use a few formulae describing the set of codewords of certain error correcting codes, for which the number of models and the minimum distance is known by construction.

More precisely, we consider BCH codes [15, 5], that are very well-known error-correcting codes whose minimal distance among the codewords is lower-bounded by construction. The property of such codes we shall use is the following:

For every $q\geq 3$ and $t<2^{q}-1$, there exists a BCH code such that codewords have $n=2^{q}-1$ bits, including $k\geq n-qt$ parity-check bits, and their minimum distance is $d_{min}\geq 2t+1$.

From the theory of error-correcting codes, we know that every binary linear $[n,m,d]$ block code $\mathcal{C}$ (i.e. a code with codeword length $n$, message length $m$ and minimum distance $d$) can be defined by its parity check matrix $H$, i.e. a $m\times n$ (with $m\stackrel{{\scriptstyle\triangle}}{{=}}n-k$) binary matrix such that $u\in\mathbb{F}_{2}^{n}$ is a codeword of $\mathcal{C}$ if and only if

[TABLE]

where we use the vector-matrix multiplication in the field $\mathbb{F}_{2}$ and $\underline{0}$ denotes the $m$-ary zero vector. Let $\varphi_{H}(u)$ be the propositional formula encoding that $u$ is a codeword of $\mathcal{C}$: starting from (25), $\varphi_{H}(u)$ can be expressed as a conjunction of $m$ XOR constraints (assuming $H$ has full rank):

[TABLE]

Thus, once fixed $n$, $m$ and $t$, we can calculate the corresponding matrix $H$ and the associated formula $\varphi_{H}$; the latter will have $2^{m}$ models (every sequence in $\mathbb{F}_{2}^{m}$ will yield a different model for $\varphi_{H}$), with Hamming distance $d_{min}$.

In this way, we have created the following CNF formulae:

[TABLE]

For these formulae, we run 3 kinds of experiments. First, we run the tool for every formula without using the improvements of the bounds given by knowing the minimum distance (i.e., we used Theorem 3.9 by setting $d=1$). Second, we run the tool for every formula by using the known minimum distance. Third, we run the state-of-the-art tool for approximate model counting, called ApproxMC3 [23] (an improved version of ApproxMC2 [7]). The results obtained are reported in Table 2.

To compare our results with theirs, we have to consider that, if our tool returns $[l,u]$, then the number of models lies in $[\lfloor 2^{l}\rfloor,\lceil 2^{u}\rceil]$ with error probability $\delta$ (set to 0.1. in all experiments). By contrast, if ApproxMC3 returns a value $M$, then the number of models lies in $\left[\frac{M}{1+\epsilon},M(1+\epsilon)\right]$ with error probability $\delta$ (again, set to 0.1 in all experiments). So, we have to choose for ApproxMC3 a tolerance $\epsilon$ that produces an interval of possible solutions comparable to what we obtain with our tool. The ratio between the sup and the inf of our intervals is $2^{2\max(\alpha,\beta)+1}$ (indeed, $A$ always returned an interval such that $u-l\leq 2\max(\alpha,\beta)+1$); when $\alpha=\beta=1.5$, the value is 16. By contrast, the ratio between the sup and the inf of ApproxMC3’s intervals is $(1+\epsilon)^{2}$; this value is 16 for $\epsilon=3$.

In all formulae that have “sufficiently many” models – empirically, at least $2^{11}$ – our approach outperforms ApproxMC3. Moreover, making use of the minimum distance information implies a gain in performance. Of course, the larger the distance, the greater the gain – again, provided that the formula has sufficiently many models: compare, e.g., the first and the last formula.

4.3 Towards a practical methodology

To be used in practice, our technique requires a lower bound on the minimum Hamming distance between any two models of $\phi$. We discuss below how error-correcting codes might be used, in principle, to obtain such a bound. Generally, speaking an error-correcting code adds redundancy to a string of bits and inflates the minimum distance between the resulting codewords. The idea here is to transform the given formula $\phi$ into a new formula $\phi^{\prime}$ that describes an encoding of the original formula’s models: as a result $\#\phi^{\prime}=\#\phi$, but the models of $\phi^{\prime}$ live in a higher dimensional space, where a minimum distance between models is ensured.

Assume that $\phi(y)$ is already in Conjunctive Normal Form. Fix a binary linear $[n,m,d]$ block code $\mathcal{C}$ (i.e. a code with $2^{m}$ codewords of $n$ bits and minimum distance $d$), and let $G$ be its generator matrix, i.e. a $m\times n$ binary matrix such that the codeword associated to $u\in\mathbb{F}_{2}^{m}$ is $uG$ (where we use the vector-matrix multiplication in the field $\mathbb{F}_{2}$). The fact that a $c\in\mathbb{F}_{2}^{n}$ is a codeword can be expressed by finding some $u$ that satisfies the conjunction of the $n$ XOR constraints:

[TABLE]

Again, the important condition here is that $G$ be sparse (on its columns), so that the above formula effectively corresponds to a conjunction of sparse XOR constraints. That is, we should confine ourselves to low-density parity check (LDPC) codes [11, 19]. Now, we consider the formula

[TABLE]

and prove the following result.

Proposition 4.1

$\#\phi=\#\phi^{\prime}$.

• Proof: Trivially, every model $\sigma$ of $\phi$ induces a model $\sigma G$ for $\phi^{\prime}$. For the converse, let $\sigma^{\prime}$ be a model of $\phi^{\prime}$; this means that there exists a $\sigma$ such that $\sigma^{\prime}=\sigma G$ and $\sigma$ satisfies $\phi$. Moreover, as we now prove, there is just one such $\sigma$ (so, the function associating $\sigma$ to $\sigma G$ is bijective). Indeed, the mapping from $\mathbb{F}_{2}^{m}$ to $\mathbb{F}_{2}^{n}$ induced by multiplication by $G$ is injective. To see this, consider $G$ in standard form, i.e. $G=[I_{m}\ \ A]$, where $I_{m}$ is the identity matrix of order $m$ (it is well-known that every generator matrix can be put in this form by generating an equivalent code – see, e.g., [21, Section 1.2]). Thus, assume that $c\stackrel{{\scriptstyle\triangle}}{{=}}\sigma G=\sigma^{\prime}G\stackrel{{\scriptstyle\triangle}}{{=}}c^{\prime}$; then,

[TABLE]

For $c^{\prime}_{i}$ similar values can be obtained, with $\sigma^{\prime}$ in place of $\sigma$. Thus, trivially, $\sigma=\sigma^{\prime}$.

If we now assume a minimum distance of $d$ when applying Theorem 3.9, we have a decrease in the feasibility threshold $\lambda^{*}$, as prescribed by (24). This gain must of course be balanced against the increased number of boolean variables in the formula (viz. $n$). We will have an actual advantage using $\mathcal{C}$ over not using it (and simply assuming $d=1$) if and only if, by using $\mathcal{C}$, the expected length of the resulting XOR constraints is actually smaller. By letting $\lambda^{*,{d}}\stackrel{{\scriptstyle\triangle}}{{=}}\lambda^{*}_{1}(s,n,\beta,d)$, the latter fact holds if and only if

[TABLE]

or equivalently $\lambda^{*,{d}}\leq R\lambda^{*,{1}}$, where $R\stackrel{{\scriptstyle\triangle}}{{=}}\frac{m}{n}$ is the rate of $\mathcal{C}$. This points to codes with high rate and big minimum distance. Despite these two parameters pull one against the other, (26) can be fulfilled, and good expected length bounds obtained, by choosing $\mathcal{C}$ appropriately.

For example, [10] presents a $[155,64,20]$-LDPC code, that is a code with block length of 155, with $2^{64}$ codewords and with minimum distance between codewords of 20. In Fig. 2 we compare the expected length of the resulting XOR constraints in the two cases – $m\times\lambda^{*}(s,m,\beta,1)$ (without the code, for $m=32$ and $m=64$) and $155\times\lambda^{*}_{1}(s,155,\beta,20)$ (with the code) – as functions of $s$, for fixed $\beta=1.5$. As seen from the plots, the use of the code offers a significant advantage in terms of expected length up to $s=10$ and $s=26$, respectively.

We have performed a few tests for a preliminary practical assessment of this idea. Unfortunately, in all but a few cases, the use of the said $[155,64,20]$-LDPC code does not offer a significant advantage in terms of execution time. Indeed, embedding a formula in this code implies adding 155 new XOR constraints: the presence of so many constraints, however short, apparently outweights the benefit of a minimum distance $d=20$. We hope that alternative codes, with a more advantageous block length versus minimum distance tradeoff, would fare better. Indeed, as we showed in Table 1, relatively small distances (e.g. $d=5$) can already give interesting gains, if the number of extra constraints is small. We leave that as subject for future research.

5 Conclusion

We have studied the relation between sparse XOR constraints and minimum Hamming distance in model counting. Our findings suggest that minimum distance plays an important role in making the feasibility threshold for $\lambda$ (density) lower, thus potentially improving the effectiveness of XOR based model counting procedures. These results also prompt a natural direction for future research: embedding the set of models into a higher dimensional Hamming space, so as to enforce a given minimum distance.

Beside the already mentioned [9], our work also relates to the recent [2]. There, constraints are represented as systems $Ay=b$, for $A$ a random LDPC matrix enjoying certain properties, $b$ a random vector, and $y$ the variable vector. Their results are quite different from ours, but also they take the geometry of the set of models into account, including minimum distance. In particular, they make their bounds depend also on a “boost” parameter which appears quite difficult to compute. This leads to a methodology that is only empirically validated – that is, the model count results are offered with no guarantee.

Acknowledgements

We thank Marco Baldi, Massimo Battaglioni and Franco Chiaraluce for providing us with the generator and parity check matrices of the LDPC code in Subsection 4.3.