The Picat-SAT Compiler

Abstract

SAT has become the backbone of many software systems. In order to make full use of the power of SAT solvers, a SAT compiler must encode domain variables and constraints into an efficient SAT formula. Despite many proposals for SAT encodings, there are few working SAT compilers. This paper presents Picat-SAT, the SAT compiler in the Picat system. Picat-SAT employs the sign-and-magnitude log encoding for domain variables. Log-encoding for constraints resembles the binary representation of numbers used in computer hardware, and many algorithms and optimization opportunities have been exploited by hardware design systems. This paper gives the encoding algorithms for constraints, and attempts to experimentally justify the choices of the algorithms for the addition and multiplication constraints. This paper also presents preliminary, but quite encouraging, experimental results.

Appendices

A The Transformation Algorithm for $X + Y = Z$

The transformation algorithm replaces negative domain values by non-negative domain values in the addition constraint. For the constraint $X+Y = Z$, if any of the operands has a domain with negative values, this method finds the smallest integer k such that abs $(X) < 2^{k-1}$/, abs $(Y) < 2^{k-1}$, and abs $(Z) < 2^k$, and transforms the original addition constraint to $Z' = X'+Y'$, where $X' = X+2^{k-1}$, $Y' = Y+2^{k-1}$, and $Z' = Z+2^k$. The newly introduced variables $X'$, $Y'$, and $Z'$ are guaranteed not to include negative values in their domains, and therefore the constraint $X'+Y' = Z'$ can be Booleanized as $X'$ .m+$Y'$ .m = $Z'$ .m.

The question is how to Booleanize the newly introduced constraints. Consider the constraint $X' = X+2^{k-1}$. Let X .m = $X_{k-1}\ldots X_nX_{n-1}\ldots X_1X_0$, and $X'$ .m = $X'_{k-1}\ldots X'_1X'_0$ ($k > n$, $X_i$ = 0 for $i = k-1, \ldots , n$). Note that 0 s are added in the high end of X .m in order for it to have the same length as $X'$ .m. The constraint $X' = X+2^{k-1}$ can be translated to a conjunction of the following two conditional constraints:

Note the unsigned addition X .m + $X'$ .m = $2^{k-1}$ can be Booleanized using a much simpler logic than for the general addition. In particular, no new variables are necessary for carries in the addition. In order for the constraint to hold, the following formula must hold:

The two Boolean variables at the lowest end, $X_0$ and $X'_0$, must be equal. Otherwise, the lowest bit of the sum cannot be 0. The intuition of the logic of the for loop is that if there is an 1 at some position, then there must be exactly one 1 at each of the higher positions in order for the sum to be equal to $2^{k-1}$. Since no negative zero is allowed, at least one of $X_i$s is 1. In order for the sum to be equal to $2^{k-1}$, $X'_{k-1}$ must be 0.

The idea of removing negative domain values through transformation is well known in linear programming. Unlike in linear programming, however, the transformation is only performed locally on negative-domain variables in addition constraints, and all other constraints, such as abs( X ) = Y, are not affected.

For a negative-domain variable X that occurs in multiple addition constraints, an optimization can be employed to avoid introducing new variables unnecessarily. The compiler memorizes the transformation $X' = X+2^{k-1}$ in a table. In case the same transformation is required by another addition constraint, then the compiler fetches $X'$ from the table, rather than introducing new variables.

Table 4 compares the enumeration (enum) and transformation (trans) algorithms, using the constraint $Z = X+Y$, where X and Y are in $-N..N$. The code size is not informative on which encoding is better: the enum encoding uses fewer variables but more clauses than the trans encoding.⁸ The time shows that the enum encoding is favorable. This result led to the adoption the enum encoding by Picat-SAT for addition constraints.

Table 4. A comparison of two encodings for $Z = X+Y$

B Karatsuba’s Divide and Conquer Algorithm for $X \times Y = Z$

Karatsuba’s algorithm [20] is a well-known algorithm for multiplying big integers. It can be applied to numbers in any base. The basic idea of the algorithm is to divide and conquer, splitting large numbers into smaller numbers, until the numbers are small enough.

Let X and Y be two N-digit binary strings. If N is small enough, then the multiplication constraint is Booleanized using shift-and-add. If N is big, then this algorithm selects an integer M ($1 \le M \le N-1$ ) and splits both X and Y into two parts as follows:

where $X_l$ and $Y_l$ are less than $2^M$. The product $X\times Y$ is then

where

The resulting formulas require three multiplications, plus some additions, subtractions, and shifts.

Table 5 compares the shift-and-add (saa) and Karatsuba (kara) algorithms, using the constraint $Z = X\times Y$, where X and Y are in $-N..N$. The base-case size for the Karatsuba algorithm is set to 3 (i.e., X .m $\le$ 7 or Y .m $\le$ 7).

Two observations can be made about the results: first, the code sizes only grow slightly with N no matter which algorithm is used; and second, kara uses more variables and generates more clauses than saa. The Karatsuba algorithm is well used for multiplying big integers and its advantage cannot be witnessed unless the operands are really big. Nevertheless, big domains rarely occur in CSPs. This experimental comparison naturally resulted in the adoption of the shift-and-add algorithm by Picat-SAT for multiplication constraints.

Table 5. A comparison of two encodings for $Z = X\times Y$