Multi-step partitioning combined with SOM neural network-based clustering technique effectively improves SAT solver performance

SAT solution based on clause cluster

The study of Fan et al. (2014) proposes a divide and conquer strategy for tackling SAT problems, which is the foundation for all of our research. Industrial practical problems are usually composed of multiple modules, such as a central processing unit (CPU) circuit consisting of modules such as controllers, arithmetic logic units, registers, etc. The logic gates within the modules are closely connected, while the two logic gates in different modules have relatively small connections. The existence of modules generates structural information for actual problems. Similarly, SAT problems transformed from industrial practical problems will also contain this structural information. However, the traditional SAT algorithm directly solves the actual problem after converting it into the CNF format, which leads to the structure information not being used. Theoretically and experimentally, it has been demonstrated that partitioning the original SAT instance into many clusters and solving each cluster individually may considerably increase the algorithm’s efficiency if the partition is reasonable (Fan et al., 2014). The theoretical analysis is as follows:

For example, a SAT instance in the form of CNF is shown in Eq. (1).

(1) $$F=\left(x_1\vee x_2\vee x_3\right)\wedge \left(\mathrm{\neg }{x}_1\vee x_2\vee \mathrm{\neg }{x}_3\vee x_4\right)\wedge \left(x_2\vee x_3\vee \mathrm{\neg }{x}_4\right)\wedge \left(\mathrm{\neg }{x}_3\vee x_4\vee x_5\right).$$

It contains five variables and four clauses. If the original instance is divided into the following two clusters: $\left(x_1\vee x_2\vee x_3\right)$, $\left(\mathrm{\neg }{x}_1\vee x_2\vee \mathrm{\neg }{x}_3\vee x_4\right)$ and $\left(x_2\vee x_3\vee \mathrm{\neg }{x}_4\right)$, $\left(\mathrm{\neg }{x}_3\vee x_4\vee x_5\right)$, Considering that the variables shared by these two clusters are $x_2$ and $x_3$, if the two variables $x_2$ and $x_3$ are first assigned, the two divided clusters can be solved separately. If both clusters are satisfiable, then the entire problem is satisfiable. If one of the cluster is unsatisfiable, then re-assign $x_2$ and $x_3$ and repeat the above-mentioned solving process separately. If all the assignments up to $x_2$ and $x_3$ have been traversed but there is no satisfiable clusters, then the original SAT problem is unsatisfiable.

The theoretical solution time of direct solving and solve after division are as follows: Assuming that the original SAT problem contains $N_{sum}$ variables, the first cluster contains $N_1$ variables, the second cluster contains $N_2$ variables, and the common variables of the two clusters are $N_{com}$, obviously Eq. (2) holds.

(2) $$N_{sum}=N_1+N_2-N_{com}.$$

Since each variable has only two assignments of true or false, after using the divide and conquer method, the solution time of the original SAT problem is expressed by Eq. (3).

(3) $$T_{div}=t_s\times 2^{N_{com}}\times \left(\left(2^{N_1-N_{com}}\right)+\left(2^{N_2-N_{com}}\right)\right)=t_s\times \left(2^{N_1}+2^{N_2}\right).$$

The direct solution time is given by Eq. (4).

(4) $$T_{dir}=t_s\times 2^{N_{sum}}$$where $t_s$ is the time for a single assignment. Since both $N_1$ and $N_2$ are smaller than $N_{sum}$ in most cases, $T_{div}$ is usually less than $T_{dir}$, i.e., as long as the division is reasonable, the total solution time will be shortened.

From the analysis above, it can be seen that the division method of the original SAT instance is one of the most important elements in this procedure, we propose a method to divide the original SAT problems efficiently, which shortens the solution time dramatically.

SOM neural network

The self-organizing map (SOM) neural network was described as a competitive learning unsupervised neural network by Kohonen (1990). It has two layers, an input layer and an output layer, both of which are completely interconnected. The output layer neurons have a certain topology, with planar structures being the most prevalent, while the number of neurons in the input layer is equal to the size of the input vector. A vector with the same length as the number of input layer neurons makes up each output layer neuron’s feature. In the scenario of clustering, neurons in the input layer are set as the dimension of the samples to be clustered, and neurons in the output layer are set as the number of target clusters when utilized for clustering. The samples are fed into the network, which is then trained. The clustering procedure comes to a finish when the output layer neurons after training correlate to various samples. The SOM network exhibits great generalization capabilities throughout the clustering process and is particularly well suited for extracting topological structure from high-dimensional samples. Figure 1 depicts the SOM network structure with a plane output layer, where $x_i(i=1,2,\dots ,n)$ represents each dimension of the n-dimensional vector to be clustered.

The network clustering process is as follows:

• 1.

  Initialize the number of neurons in the input layer, the topology and number of neurons in the output layer, and the feature vector of each neuron in the output layer.

• 2.

  Input all the samples to be clustered according to a certain order, find the output layer neuron closest to each sample as the winning neuron, and update the feature vectors of this neuron and some surrounding neurons.

• 3.

  After the training process, input all samples into the network again, and record the neuron closest to each sample. For the same neuron in output layer, all recorded samples are the content of this cluster.

In the following section, we will show how to use SOM network to cluster the clauses in a STA problem and the effectiveness of this approach.

Multi-step partition

Division process

Multi-level division techniques have been widely applied in the field of circuit division, particularly VLSI division (Cong & Lim, 2004; Saab, 2004; Li & Behjat, 2006). The integrated circuit is first transformed into a hypergraph, where nodes represent circuit modules and hyperedges represent signal nets in the circuit. Initially, two or more highly correlated vertices are coalesced, and this contraction process is iteratively repeated until the original hypergraph is mapped to a significantly smaller hypergraph. Following an initial partitioning of this reduced hypergraph, the contracted nodes are progressively uncoarsened. During this uncoarsening phase, the initial partition is refined, ultimately achieving the partitioning of the entire large-scale hypergraph. We apply this multi-step division method to the SAT problem. Here is the specific division procedure:

• 1.

  Preliminary clustering. Each clause of the SAT instance in CNF format is taken as an element for preliminary clustering. That is to say, write the set of all clauses containing independent variables respectively, and aggregate any two clauses with subset relations into one category. For example, a clause 1: $\left(x_1\vee x_2\right)$ contains the set of independent variables $\left\{x_1,x_2\right\}$, clause 2: $\left(x_2\vee \mathrm{\neg }{x}_3\right)$ contains the set of independent variables $\left\{x_2,x_3\right\}$, clause 3: $\left(x_1\vee x_2\vee \mathrm{\neg }{x}_3\right)$ contains the set of independent variables $\left\{x_1,x_2,x_3\right\}$, since $\left\{x_1,x_2\right\}$ is a subset of $\left\{x_1,x_2,x_3\right\}$, and $\left\{x_2,x_3\right\}$ is a subset of $\left\{x_1,x_2,x_3\right\}$, then these three clauses are clustered into one category.

• 2.

  SOM clustering. Take each cluster after preliminary clustering as a sample and input it into the SOM network for clustering. Use each cluster of the SOM network clustering result as a new sample, and apply the SOM network again for clustering. Details of using SOM neural network are in “Clustering With SOM Network”.

• 3.

  Minimum cut division. When the total number of clusters of the SOM network clustering is smaller than 100, the clustering is stopped, and the simulated annealing algorithm (Steinbrunn, Moerkotte & Kemper, 1997) is used for minimum cut division. Firstly, the output layer of the SOM network is divided into two parts based on the diagonal, named $C_A$ and $C_B$. Each cluster is assigned to either $C_A$ or $C_B$ according to its position, as shown in Fig. 3. Then randomly move a cluster from $C_A$ to $C_B$, calculate whether the number of the cut-set variables between $C_A$ and $C_B$ is reduced, and if so, keep this operation, if the number of cut-set variables does not decrease, keep this operation with a certain probability. Repeat the cluster assignment between $C_A$ and $C_B$ until the number of iterations reaches the limit or the annealing process ends.

Finally, the original SAT problem is divided into two large clusters, $C_A$ and $C_B$, and the division step ends. The flowchart of multi-step division is as Fig. 4.

Advantages of modular solution

Because SOM network has the ability of clustering based on structural information, each step of multi-step clustering can extract the structural information of the original SAT problem at a certain level, and finally divide the original SAT into multiple clusters. Due to the correspondence between clauses in the CNF format SAT problem and modules in industrial practical problems, this step also divides the practical problem into multiple modules. Our approach divides the original problem into two parts finally, which are solved separately to reduce the scale of the original problem and improve the efficiency of solution.

Figure 5 is a schematic diagram of the modular division of the practical problem, where “Module3” is the module that makes the corresponding SAT problem unsatisfiable. In this case, solving $C_B$ will directly lead to unsatisfiable, thus reducing the solution time.

Clustering with SOM network

In this subsection, We will discuss how to use SOM neural network to cluster clauses and why SOM neural network can leverage structure information from industrial problem effectively.

Space mapping ideas

According to the usage guidelines of SOM neural networks, each clause must be mapped to a point in a high-dimensional space in order to cluster all the clauses. These are the precise steps:

• 1.

  The number of variables in this SAT problem is used as the dimension of the target space, that is, the variables correspond to the dimensions one by one.

• 2.

  If a clause contains variable $x_i$, then the value of the point corresponding to this clause is 1 on this dimension, otherwise it is 0.

Examples are as follows:

For SAT instance Eq. (5):

(5) $$F=\left(x_1\vee x_2\vee \mathrm{\neg }{x}_3\right)\wedge \left(x_1\vee \mathrm{\neg }{x}_2\right)\wedge \left(\mathrm{\neg }{x}_2\vee x_3\right)\wedge \left(x_1\vee x_3\right)$$

Eq. (5) contains three variables and four clauses (C1: $\left(x_1\vee x_2\vee \mathrm{\neg }{x}_3\right)$, C2: $\left(x_1\vee \mathrm{\neg }{x}_2\right)$, C3: $\left(\mathrm{\neg }{x}_2\vee x_3\right)$, C4: $\left(x_1\vee x_3\right)$), so the target space is three-dimensional, the number of samples is 4. The four points of the mapping result are: (1, 1, 1), (1, 1, 0), (0, 1, 1), (1, 0, 1). Its position in three-dimensional space is shown in Fig. 6, where $X_1$, $X_2$ and $X_3$ represent three dimensions respectively.

Since the distance between (1, 1, 0) and (1, 1, 1) is 1, and the distance between (1, 1, 0) and (0, 1, 1) is $\sqrt{2}$, obviously, the latter distance is longer. This is also consistent with the intuitive feeling of the similarity between clauses (there are two common variable between $C_1$ and $C_2$, and there is one common variables between $C_2$ and $C_3$). After mapping all the clauses of a SAT instance, they can be input into the SOM network for clustering.

Periodic boundary modification

After analyzing the mechanism of using SOM network to conduct clustering tasks, we note there are some drawbacks in traditional output layer, to enhance the ability of clustering, We modify the topological relationship of neurons in the boundary layer of the SOM network, and apply it to the subsequent clustering process. There are two reasons that motivate us to make this modification.

Reason 1: Throughout the training phase, the characteristics of the neurons in the network output layer will continue to converge on the average value of one or more samples. As a result of this procedure, the neuron has a higher likelihood of being the final topological clustering location for these samples. Following training, the neurons in the output layer typically exhibit higher resemblance to the peripheral neurons (Kohonen, 1990). It is possible to think of numerous neurons with similar spacing as forming a whole. It is important to note that the neurons in the center of the entire partially convey its properties. If, during training, a neuron that belongs in the center is moved to the output layer’s edge, other neurons that belong nearby will find it challenging to connect with it, which will result in the loss of some structural information.

Reason 2: Compared to the intermediate neurons in the output layer, the neighbors of the neurons near the edge of the output layer are fewer (there are three or five neurons in a circle around the neurons at the edge, and 8 neurons in a circle around the neurons at the inside). which means that throughout the entire network training period, they will receive less updates than the internal neurons. The training’s overall clustering effect will be somewhat impacted by this mismatch in the amount of updates. As a result, edge neurons’ neighbor properties must be modified.

To make the neurons at boundary have the same property as internal neurons, We logically connect the leftmost neurons of the square output layer with the rightmost neurons, and logically connect the upmost neurons with the downmost neurons. As shown in Fig. 7, after modification, neurons A and B become neighbors.

The frequency of each neuron’s victories both before and after the periodic border change is shown in Fig. 8. It is clear that the modified output layer no longer has a logical boundary and that, during training, it shares the same status as an internal neuron.

Solving process after partition

Instead of comparing the solving results of sub-problems directly by Fan et al. (2014), which may waste much time on explored solution space. We introduce a clause learning mechanism in the process of solving the SAT problem after division to form a systematically search algorithms.

Firstly, the sub-thread solver is used to solve the SAT problem corresponding to $C_A$. If the solution result is UNSAT, the original SAT problem is UNSAT. If the solution result of $C_A$ is SAT, then all the cut-set variable assignments are substituted into $C_B$, and then the sub-thread solver is used to solve the problem $C_B$. If the $C_B$ cluster is SAT, the original SAT problem is satisfiable. If the $C_B$ cluster cannot be satisfied, it means that the assignment of the cut-set variable at this time will conflict. The above process needs to be re-iterated. In order to prevent the $C_A$ cluster from outputting the previous cut-set variable assignment results again, the clauses learned in the previous iteration need to be added to the $C_A$. For example, when $C_A$ is SAT, the cut-set variables are x₁, x₂, and x₃, and the output result is $x_1=1$; $x_2=0$; $x_3=1$, but this assignment results in $C_B$ being unsatisfied, then add a clause $\left(\mathrm{\neg }{x}_1\vee x_2\vee \mathrm{\neg }{x}_3\right)$ to $C_A$. Secondly, exchange the positions of $C_A$ and $C_B$, repeat the above process, until a certain iteration, both $C_A$ and $C_B$ are SAT or the first cluster is UNSAT, the solution ends.

The flow chart of solving two clusters is shown in Fig. 9, where $C_A/C_B$ refers to $C_A$ or $C_B$, and the positions are exchanged after each clause learning process.

Clustering results

In terms of obtaining structural information, the SOM network outperforms the strategy suggested in the article (Fan et al., 2014) by a wide margin. In contrast to the article (Fan et al., 2014), which necessitates numerous adjustments to various parameters for different benchmarks, including similarity threshold and minimum cluster number. In addition, clustering SAT problems with huge scale or close numbers of variables in each clause may result in bad effect. However, SOM neural networks can overcome this flaw, as demonstrated by the following example:

In the equivalence test of combinational logic circuits, a common method is to connect the circuit to be optimized and the optimized circuit into a miter structure (Brand, 1993). That is to say, join the same input ports of two circuits together, connect the identical output ports to an XOR gate, connect the outputs of all of these newly connected XOR gates to an OR gate, and utilize the output of the OR gate as the miter circuit’s overall output. The circuits before and after optimization are not equivalent if there is an input assignment that causes the final output to be true. If a SAT solver is used to solve this inspection procedure, each gate (AND, OR, NOT, and XOR) must be translated into a clause. These clauses are then joined by conjunctions, and the output port of the miter circuit is set to true. The two circuits are equivalent if the SAT problem is unsatisfiable; otherwise, they are not equivalent.

Figure 10 depicts a four-bit array multiplier with eight input ports and eight output ports, which is made up of 16 one-bit multipliers. As several of the original circuit’s pins had a 0 as their input, we simplify it to a circuit made up of nine one-bit multipliers and three full adders. After using the method in article (Fan et al., 2014) to convert the circuit to a SAT problem, it has a total of 253 clauses and 85 variables.

Using the SOM network and the method described in the article (Fan et al., 2014), clustering was carried out. The results demonstrate that the SOM network produces 40 clusters, each of which has been colored to indicate which module it belongs to (one-bit multiplier or full adder), as shown in Fig. 11. This means that the SOM neural network clusters logic gate which belong to the same module to nearby neurons, further, it can leverage the structure information from real-world SAT problem.

However, when the clustering threshold is adjusted to 0.51, the approach described in Fan et al. (2014) produces a clustering result of 62 clusters. The clustering outcome is 1 cluster when the threshold is set to 0.5. The modular information of the original circuit is challenging to replicate. It is evident that the SOM network is proficient at extracting structural information.

Multi-step division results

To form a fair comparison with Fan et al. (2014), we use the the same benchmarks, namely SATLIB (Hoos & Stützle, 2000) and SAT competition 2013 Balint et al. (2013a, 2013b) to conduct experiments, and list some of the division results in Table 1, where the first column is the file name, we abbreviated part of the file name² , the second column is the number of variables, and the third column is the number of clauses, and the fourth column is the number of cut-set variables of the $C_A$ and $C_B$ after partition. It can be seen from Table 1 that in top ten benchmark, which are from industrial problem, the number of cut-set variable are less than 5% of variables in original problem. While in the last two benchmarks, which are generated randomly, the number of cut-set variables takes more than 5% of original problem variables. This is because the random-generated problems don’t have structure information thus they can’t be divided by modules.

To demonstrate the role of each part in the multi-step partition procedure, Table 2 shows the number of total clusters, max cluster size and cut-set variables changes in one representative benchmark³ . As the process of division moves forward, it can be seen that the total number of clusters declines while the number of variables in the largest cluster rises, which means our multi-step partition method cluster the original problem gradually and each step contributes to the final division result.

Time comparison

To compare the time used by our algorithm and other method, we conduct experiments on three benchmarks, namely SATLIB (Hoos & Stützle, 2000), SAT competition 2013 Balint et al. (2013a, 2013b), and SAT competition 2023 (Balyo et al., 2023). The first two benchmarks are selected because they are also used in Fan et al. (2014), the third benchmarks are the latest open source benchmark from SAT competition. In terms of sub-thread solver, we select MiniSat (Giunchiglia & Tacchella, 2004), Glucose (Audemard & Simon, 2018) and CaDiCaL (Biere et al., 2024). MiniSat is one of the most well-known commercial solvers, which performs exceptionally well in industrial scenarios. Glucose is a derivative of MiniSat, who won 8 years of SAT competition since emergence. CaDiCaL is one of the most modern SAT solvers and its variant won first place in the 2023 SAT Competition in main track. The maximum number of iterations for the simulated annealing algorithm is set to 5,000 in “Min-cut and Bisection”. All experiments are conducted on a Intel Core i7 11800H machine with 16 GB of memory and Ubuntu 18.04 operating system.

There are more than one thousand benchmarks in the three benchmarks suite, running all the benchmarks will be a time consuming task, so we select all the benchmarks with less than 10,000 clauses to conduct comparison experiment. Our study focus on the effectiveness of partition before solving instead of mechanism of different sub-thread solver, so we compare the performance between partition before solving and directly solving. Table 3 shows the result of four comparisons across four benchmark suites. Winning rate denotes the portion of benchmarks our algorithm use less time than directly solving, speed up rate denote the average speed up rate on wining benchmarks. ‘SOM’ denotes using SOM neural network to conduct partition while ‘Sim’ denotes using partition methods from Fan et al. (2014). From Table 3 we can see that in three benchmark suites except ‘SC2013-Random’, our method perform better than directly solving to a large extent when using different sub-thread solvers, which means our partition algorithm is suitable for various solvers. In ‘SC2013-Random’ benchmark suite, we only speed up on a small percentage of benchmarks, this is because the random-generated SAT problems lack of structure information form real-world problem, thus a reasonable division of these problems is hard to achieve, making it difficult to reduce the overall solution time. In addition, our partition method outperforms that of Fan et al. (2014) dramatically; our method speed up more than 69% instances of three industrial benchmark suites while that of Fan et al. (2014) speeds up less than 30%. Which demonstrates the practicality of our algorithm.

Table 4 shows detail results of some benchmarks where ‘SOM+solver’ represents dividing first and then calling the corresponding solver to solve, the time unit is seconds. From the table, it can be seen that our algorithm significantly improves the solving efficiency for most industrial examples. The method of partitioning first and solving later did not show advantages for instances ‘am_5_5.shuffled-as.sat03-361’, ‘vmpc_29.cnf’ and ‘571a2…9e’, which may be due to the special structure of the instances. At the same time, it can be seen that there is not much difference between the pure solving time (total solution time minus partition time) of these two instances and directly calling the solver to solve, which is due to the use of the min-cut mechanism in the “Min-cut and Bisection”. This proves that using the min-cut instead of bisection, our algorithm will not significantly prolong the solution time in extreme situations. The last two rows in Table 4 show the results of random-generated instance, our method exhibits inferior performance relative to direct solving, as it prioritizes structural information extraction from stochastic problem instances, which maybe meaningless.

Table 5 shows detail results of different partition methods. The first column in Table 5 is the file name, the second column is the source of each benchmark, the third column is time used for the whole partition, the fourth column is the solution time of directly calling MiniSat, the fifth column is the total solution time using our partition algorithm, and the sixth column shows the solution time using the partitioning algorithm in article (Fan et al., 2014). Table 5 shows that compared to the algorithm in article (Fan et al., 2014), our algorithm exhibits greater acceleration in most industrial instances except ‘am 6 6.shuffledas.sat03362’ and ‘571a2…9e’. For instance ‘am 6 6.shuffledas.sat03362’, this is mainly due to the large number of variables and clauses (2,269 variables and 7,814 clauses) it contains, making partitioning time a bottleneck in its efficiency. While for ‘571a2…9e’, the directly solving time is less than our partition time, which showcases the limitation of our algorithm on special problems. In addition, Similar to our algorithm, Fan et al. (2014) also perform poorly on random benchmarks which means the idea of extracting structure information from STA problem only works on industrial problems.