Transformer-based Machine Learning for
Fast SAT Solvers and Logic Synthesis

For a logic gate with function $z=f(a,b,\dots)$, it equals to logic expression $(z\Rightarrow f(a,b,\dots))\cdot(f(a,b,\dots)\Rightarrow z)$, which then derives $(\neg z+f(a,b,\dots))\cdot(\neg f(a,b,\dots)+z)$. We further expand the above equation in product of sum (POS) form to obtain the CNF for the gate. Table I summarize the CNF equations for basic logic gates,

To combine the advantages from both CNNs and RNNs, [15] presents a novel architecture, called Transformer, using only the attention mechanism. This architecture achieves parallelization by capturing recurrence sequence with attention and at the same time encodes each item’s position in the sequence. As a result, Transformer leads to a compatible model with significantly shorter training time. The self-attention mechanism of each Transformer layer is depicted as a function $T:\mathbb{R}^{N\times F}\rightarrow\mathbb{R}^{N\times F}$; given $x\in\mathbb{R}^{N\times F}$, the $l$th layer $T_{l}$ computes,

where $W_{Q},W_{K}\in\mathbb{R}^{F\times D}$ and $W_{V}\in\mathbb{R}^{F\times M}$ are projection matrices for evaluating queries $Q$, keys $K$, and values $V$, respectively. $A_{l}(x)$ are self-attention matrices which describe the similarities between vector entries of $x$. The self-attention matrix $A_{l}$ is a complete graph which represents the connectivity between queries and keys. When queries and keys are loosely related, the attention map becomes a sparse matrix, similar to the aggregation phase of the Graph Neural Network (GNN). Another difference between the self-attention mechanism used in Transformer and the Graph Attention Network (GAT) [18] is that Transformer’s attention mechanism is multiplicative, which is accomplished by dot product, while GAT employs additive attention.

Each CNF equation can be formulated as,

where $V$ and $U$ are the sets of variables and clauses, respectively. Either variable $v_{i}$ or $\neg v_{i}$ appears in the clause $u_{j}$, but not both at the same time. The expression can be properly presented as an undirected bipartite graph, as shown in Fig.2(a). We then construct such a bipartite graph $G((V,U),\mathcal{E})$ by defining the set of variables $V=\{v_{1},\dots,v_{n}\}$, the set of clauses $U=\{u_{1},\dots,u_{m}\}$, and edges $\mathcal{E}$ by: $e_{i,j}\in\mathcal{E}$ iff variable $v_{i}$ is involved in constraint $u_{j}$ either in positive or negative relation. To assist the message passing mechanism used in graph neural network, we further separate the bipartite graph in two sub-graphs, one for positive constraints and another for negative constraints, e.g., $\phi_{+}=(v_{1}\lor v_{2})_{u_{1}}\cdot(v_{2})_{u_{2}}\cdot(v_{3}\lor v_{4})$ and $\phi_{-}=(\neg v_{2}\lor\neg v_{4})\cdot(\neg v_{1})$. Moreover, given the adjacency matrix $A$ of the bipartite graph, each edge is assigned with a type depending on the polarity of the variable to which it connects. The positive occurrence of a variable $v_{i}$ in a clause (or factor) $u_{j}$ is represented with the positive sign $(+)$, whereas its negative occurrence $\neg v_{i}$ in $u_{j}$ gets the negative sign $(-)$. Hence, a pair of $n\times m$ bi-adjacency matrix $\textbf{A}=(A_{+},A_{-})$, which correspond to the pair $(\phi_{+},\phi_{-})$, is used to store two types of edges such that $A_{+}(i,j)=1\Leftrightarrow{v_{i}\in u_{j}}$ and $A_{-}(i,j)=1\Leftrightarrow{\neg v_{i}\in u_{j}}$, the example of decomposed sub-graphs are shown in Fig.2(b). Here $v_{i}\in u_{j}$ implies that $v_{i}$ instead of its negation $\neg v_{i}$ is directly involved in $u_{j}$. Each edge $e_{i,j}\in\mathcal{E}$ is then assigned a value equal to $1$ for edges in $A_{+}$ and $-1$ for edges in $A_{-}$. With the graph representation, graph neural network can be applied to solve symbolic reasoning problem, e.g., CSP/SAT-solver [12, 19]. These two sub-graphs are then applied with the self-attention on positive and negative links, i.e., the positive and negative constraints in CNFs, respectively, as explained in Section III-B.

Due to bipartite properties, variables are only connected to clauses, and vice versa, as shown in Figure 2. Consequently, every node must traverse a node with different type to reach a node with same type. Furthermore, traditional GNN can only transfer messages between nodes with the same attributes. In this work, we propose to pass message through 2-hop meta-paths [16] in addition to existing edges, which enables variables (clauses) to incorporate the information from variables (clauses) that share the same clauses (variables) during the update of their states. In a CSP/SAT factor graph, we define that a meta-path $m_{i,j}=(v_{i},u_{k},v_{j})$ between nodes $v_{i}$ and $v_{j}$ exists if there exists some $u_{k}\in U$ s.t. $\exists e_{i,k}\in\mathcal{E}$ and $\exists e_{k,j}\in\mathcal{E}$. Since self-attention mechanism is not symmetric, our meta-path is directed. As a result, we get four types of meta-paths in total, i.e., $\{(+,+),(+,-),(-,+),(-,-)\}$, as illustrated in right-hand side of Fig.3. The adjacent matrix of such a meta-path can be easily computed by matrix multiplication of $A_{+}$ and $A_{-}$ or their transposes. Take $A_{(+,+)}$, $A_{(+,-)}$ as examples, the adjacency matrix $A_{(+,+)}=A_{+}A_{+}^{T}$ stores all $(+,+)$ meta-paths, and $A_{(+,-)}=A_{+}A_{-}^{T}$ stores all $(+,-)$ meta-paths. A diagonal entry $A_{(+,+)}[i,i]$ indicates the number of positive edges that $v_{i}$ has, and an off-diagonal entry $A_{(+,+)}[i,j]$ indicates the existence of $(+,+)$ meta-path from $v_{i}$ to $v_{j}$.

This work employs sparse attention coefficients for both the self-attention of meta-paths and the cross-attention between variables and clauses, as explained in section III-D. The sparse attention coefficient is calculated according to the connectivity between graph nodes. As described in below equations: after the embedding in Equation 5, where $X=Y$ for self-attention and $X\neq Y$ for cross-attention, as shown in Figure 4. The node-to-node attention between a pair of connected nodes is computed first by an exponential score of the dot product of the feature vectors of these two nodes (Equation 6). Then the score is normalized by the sum of exponential scores of all neighboring nodes as described in Equation 7.

where $Q$, $K$, and $V$ are queries, keys, and values in Transformer’s terminology, respectively; and $q_{i}=Q(i)$, $k_{j}=K(j)$, $v_{j}=V(j)$, $\left<q,k\right>=exp\left(\frac{q^{T}k}{\sqrt{d}}\right)$, and $SM(\cdot)$ is the SoftMax operation. Finally, we obtain attention maps $\mathcal{A}$ as multi-dimension (multi-head) sparse matrices sharing the identical topology described by a single adjacency matrix, where attention coefficients are $\mathcal{A}(i,j)=\alpha_{i,j}$. The sparse matrix multiplications can be efficiently implemented in high parallelism with the tensorization of node feature gathering and scattering operations through indexation.

For a given $\text{SAT}(V,U)$, each combination of variable assignments corresponds to a probability. The original measure $\phi(V,U)$ is a non-differentiable staircase function defined on a discrete domain. $\phi(V,U)$ evaluates to $0$ if any $u_{j}\in U$ is unsatisfied, which disguises all other information including the number of satisfied clauses. For training purpose, a differentiable approximate function is desirable. Therefore, the proposed model generates a continuous scalar output $x_{i}\in[0,1]$ for each variable, and the assignment of each $v_{i}$ can be acquired through:

where $\epsilon$ is a small value to keep the generated $v_{i}$ in $\{0,1\}$. With continuous $x_{i},i={1,...,N}$, we can approximate disjunction with $max(\cdot)$ function and define $\phi(\cdot)$ as

Here, the literal function $l(x_{i},e_{ia})=\frac{1-e_{ia}}{2}+e_{ia}x_{i}$ is applied to specify the polarity of each variable. We replace the max function with a differentiable smoothmax, $S_{r}(\cdot)$:

Mathematically, $S_{\tau}(x_{1},...,x_{N})$ converges to $\max(x_{1},...,x_{N})$ as $\tau\rightarrow\infty$. We note that $\tau=5$ is enough for our model in practice. By maximizing the modified $\phi$, the proposed model is trained to find the satisfiable assignment for each CSP problem. For numerical stability and computational efficiency, we train our model by minimizing the negative log-loss

We further propose the Heterogeneous Graph Transformer (TRSAT) which adopts an encoder-decoder structure, as illustrated in Figure 5(a). It is a flexible architecture allowing the number of encoder- and decoder-layers to be adjustable.

Encoder. Within each encoder-layer, every graph node first aggregates the message (or information) from nodes of its kind through meta-paths. Note that a node (variable or clause) of bipartite graph has no direct connection within homogeneous nodes. Messages can only pass among homogeneous nodes through meta-paths. We emphasize such type of communication between nodes of the same kind as self-attention, which is implemented with homogeneous attention mechanism regarding the polarity of variables. The attention are then connected to the residual block and layer normalization [20], as shown in Figure 5 (b).

Decoder. Inside each decoder-layer, the weighted messages are passed between variables and clauses through the cross-attention mechanism, implemented as the heterogeneous attention regarding nature of graph nodes (either variables or clauses), followed by residual connection and layer normalization, as in Figure 5 (c). The attention-weighted node features are then fed into the feed-forward network (FFN) for enhancing the node feature embedding.

We initiate the discussion of the complexity from computing single attention head, multi-head follows the same analysis. Both the self-attention of meta-paths and the cross-attention between variables and clauses described in previous sections rely on the connectivity (or topology) of the relevant bipartite graphs, so the time complexity of computing these attention coefficients is $\mathcal{O}(|\mathcal{E}|\times|F|)$, where $|\mathcal{E}|$ is the number of edges in a graph and $|F|$ is the number of features of graph node. The node encoding module, which is a linear layer in the model, and the feed-forward network (FFN) module possess the time complexity of $\mathcal{O}(|V|\times F\times F^{\prime})$, for $|V|$ the number of graph nodes. As $|\mathcal{E}|\gg|F|$ and $|V|\gg|F|$, total complexity of a single attention head is proportional to the number of nodes and edges. Furthermore, space complexity of the memory footprint for sparse attention is also linear in terms of nodes and edges.

Depends on the application’s requirement, the SAT problem can be further categorized as the maximum satisfiability problem (MAX-SAT) and exact SAT. MaxSAT determines the maximum number of clauses of a given Boolean formula in Conjunctive Normal Form (CNF), which can be made true by an assignment of truth values to the formula’s variables [21]. It is a generalization of the Boolean satisfiability problem (exact SAT), asking whether a truth assignment makes all clauses valid. Machine learning-based algorithms explore the solution space by minimizing the loss to ground truth and updating their models’ weights through gradient descent during the training phase. This constraint has naturally drawn the machine learning-based approaches to focus on MaxSAT problems by performing probabilistic decision-making. Rather than obtaining the deterministic and complete solution, they approximate variable assignments. To remedy this drawback, iterative algorithms can be applied. Different from the decimation strategy employed in PDP, which selectively fixes the values of variables of the solved clauses, we deliver Algorithm 1 which conditionally removes the solved clauses and their related variables from current problem. As the decimation approach of PDP does not reduce the problem’s scale by fixing values of variables, our model can generate a faster and more efficient solution by decreasing the size of the problem.

To learn a CSP/SAT solver that can be applied to diverse classes of satisfiability problems, we selected our training set from four classes of problems with distinct distributions: random 3-SAT, graph coloring (k-coloring), vertex cover (k-cover), and clique detection (k-clique). For the random 3-SAT problems, we used 1200 synthetic SAT formulas in total from the SATLIB benchmark library [22]. These graphs, consisting of variables and clauses of various sizes, should reflect a wide range of difficulties. For the latter three graph-specific problems, we sampled 4000 instances from each of the distributions that are generated according to the scheme proposed in [19].

For evaluating our model’s performance on CNF-based logic synthesis, we collected several circuit datasets [23, 24], including various Data Encryption Standard (DES) circuits and arithmetic circuits, from real-life hardware designs, and translated them into their corresponding CNF formats. Each dataset consists of 100 to 200 samples. Each benchmark subfamily of the DES circuit models, denoted as $des\_r\_b$, is parameterized by the number of rounds ($r$) and the number of plain-text blocks ($b$). The selected arithmetic circuits consist classical adder-tree (atree) as well as Braun multipliers (braun), and are denoted by their names. The largest instances from these circuit dataset contain 14K variables and 42K clauses on average, which is comparable to medium-sized SAT competition instances [25].

Baseline models. To fully assess the validity and performance of our model in both CSP/SAT solving and CNF-based logic synthesis, we compared our framework against three main categories of baselines: (a) the classic stochastic local search algorithms for SAT solving - WalkSAT [26] and Glucose [27] (a variant of MiniSAT [7]), (b) the reinforcement learning-based SAT solver with graph neural network used for embedding phase - RLSAT [19], (c) the generic but innovative graph neural framework for learning CSP solvers - PDP [14]. Among these baselines, PDP falls into the hybrid of recurrent neural network and graph neural network based one-shot algorithm.

Hardware. Every experiment is performed on the system with AMD Ryzen 7 3700X 8 core 16 threads CPU equipped with GeForce RTX 2080 8 GB of memory GPU. Since RLSAT, PDP, and our model consists of paralizable operations, we fully deployed on the GPU. Glucose and WalkSAT, which are sequential algorithms using backtracking, are unable to exploit the GPU.

Software. Our model is implemented with PyTorch deep learning framework and employs PyTorch Geometric [28] for graph representation learning, and is able to achieve high efficiency in both training and testing by taking full advantage of GPU computation resources via parallelism.

General setup. Our model for the experiments discussed in this section is configured as follows. Structures are implemented according to the architecture presented in Figure 5. For the encoder, we adopted four layers for both the encoder-layers and decoder-layers with the number of channels setting to 64 for all of them. Optimizer Adam [29] with $\beta_{1}=0.9$, $\beta_{2}=0.98$, $\epsilon=10^{-9}$ was applied to train the model. Our learning rate varies with each step taken, and follows a pattern that is similar to the one adopted by Noam [15].