Research on Abstraction-Based Search Space Partitioning and Solving Satisfiability Problems

Abstract

Solving satisfiability problems is central to many areas of computer science, including artificial intelligence and optimization. Efficiently solving satisfiability problems requires exploring vast search spaces, where search space partitioning plays a key role in improving solving efficiency. This paper defines search spaces and their partitioning, focusing on the relationship between partitioning strategies and satisfiability problem solving. By introducing an abstraction method for partitioning the search space—distinct from traditional assignment-based approaches—the paper proposes sequential, parallel, and hybrid solving algorithms. Experimental results show that the hybrid approach, combining abstraction and assignment, significantly accelerates solving in most cases. Furthermore, a unified method for search space partitioning is presented, defining independent and complete partitions. This method offers a new direction for enhancing the efficiency of SAT problem solving and provides a foundation for future research in the field.

1. Introduction

The SAT (satisfiability) problem involves determining whether a given Boolean formula has a satisfiable assignment. As one of the classical problems in computer science and among the most notable NP-complete problems in computational complexity theory [1], SAT has been extensively studied and discussed for nearly a century. Due to its critical role in formal verification [2,3], artificial intelligence [4], and combinatorial optimization [5], efficiently solving SAT problems remains a key focus of research.

From the most straightforward perspective, solving a SAT problem entails traversing the search space. As the problem size increases, the search space expands exponentially, resulting in exponentially growing solving times, which makes direct solving infeasible for large-scale problems. To improve solving efficiency, heuristic strategies are widely employed in SAT solving [6]. The core algorithm of modern SAT solvers, conflict-driven clause learning (CDCL), significantly accelerates solving by utilizing heuristics such as clause learning, conflict-driven backjumping, and decision heuristics, building upon the foundational DPLL algorithm [7].

When employing DPLL or CDCL algorithms, the problem is solved sequentially [8], iteratively verifying potential assignments via backjumping. To further enhance solving efficiency, leveraging computational resources through parallel computation becomes another key approach. Inspired by parallelism, SAT parallel solvers have seen significant development. The two primary categories of mainstream parallel SAT solving algorithms are as follows [9,10]:

(1)

Divide-and-conquer algorithms, which partition the search space and compute different portions in parallel.

(2)

Portfolio algorithms, which employ multiple solvers with diverse restart, decision, and learning heuristics applied to parallel instances, competing to find the fastest solving path.

In both sequential and parallel solving, the essence of SAT solving lies in assigning values (1 or 0) to one or more variables and analyzing their impact on formula satisfiability through operations like constraint propagation and conflict analysis. This paper defines the search space from both topological and logical perspectives, analyzing the nature of assignments and revealing their essence as partitions of the search space.

Based on this insight, a novel search space partitioning method is proposed, differing from traditional assignment-based approaches. This method partitions the search space by merging variables, not only independently deriving sequential or parallel solving algorithms, but also being combined with assignment strategies. Experimental data indicate that, depending on the algorithm strategy, the solving time can be optimized in the majority of cases. Finally, the paper summarizes a more unified search space partitioning methodology, rigorously defining the properties of different partitions and providing a more precise analysis of various existing solving algorithms.

Organization of the Paper:

• Section 2: Reviews the most common SAT solving algorithms as well as the various solvers that implement these algorithms;
• Section 3: Defines the search space, analyzes the commonalities of algorithms in Section 2 from a topological perspective, and proposes a new solving approach distinct from the existing algorithms;
• Section 4: Explains how this new approach can be applied in solving, offering ideas for both sequential and parallel solving while discussing its interaction with the existing methods;
• Section 5: Summarizes a unified search space partitioning method, defines the properties of partitions, and analyzes the partition characteristics satisfied by the existing solving algorithms.

2. Overview of SAT Solving

2.1. Common Solving Algorithms

The most critical aspect of SAT solving is the algorithm, as the algorithm determines the foundation and underlying logic of the entire SAT solving process. Therefore, understanding the most important algorithms in SAT solving is essential.

2.1.1. Sequential Algorithms: DPLL and CDCL

The DPLL algorithm (Davis–Putnam–Logemann–Loveland Algorithm) is a classical method for solving the satisfiability problem (SAT). Proposed in 1962 by Martin Davis, Hilary Putnam, George Logemann, and Donald Loveland, it is an improvement of the earlier Davis–Putnam algorithm. Viewing the SAT solving process as traversing a decision tree, DPLL is a complete search algorithm that employs backtracking and pruning strategies [11].

Example 1.

Illustration of SAT solving process using DPLL and unit propagation.

Given the following formula,

$$F:\left(x_1\vee x_2\vee x_3\right)\wedge \left(\neg x_1\vee \neg x_2\right)\wedge \left(x_2\vee x_3\right)\wedge \left(\neg x_1\vee x_2\vee \neg x_3\right),$$

(1)

Decision:  $x_1=0$.

By assigning $x_1=1$, the formula simplifies through unit propagation:

$$F^{\prime }:(\neg x_2)\wedge (x_2\vee x_3)\wedge (x_2\vee \neg x_3),$$

(2)

Unit Propagation: $x_2=0$.

Unit propagation forces $x_2=0$, due to the clause $(\neg x_2)$. When simplifying further,

$$F^{″}:\left(x_3\right)\wedge \left(\neg x_3\right).$$

(3)

At this stage, a conflict occurs, as $x_3$ cannot simultaneously satisfy both $\left(x_3\right)$ and $(\neg x_3)$.

Backtracking: $x_1=1$.

Backtrack and assign $x_1=0$. The formula now simplifies to the following:

$$F^{‴}=\left(x_2\vee x_3\right)\wedge (x_2\vee x_3),$$

(4)

Pure Literal Elimination: $x_2=1$, $x_3=1$.

Here, $x_2$ and $x_3$ are pure literals (appearing with consistent polarity). Assign $x_2=1$ and $x_3=1$, resulting in a satisfiable formula.

Conclusion

Formula F is satisfiable with the following assignment: $x_1=0$, $x_2=1$, $x_3=1$.

From Example 1 and Figure 1, it can be observed that the search tree of formula $F$ and the DPLL algorithm’s search tree demonstrate how DPLL explores the search space by assigning values to variables and backtracking when encountering unsatisfiable states.

Conflict-driven clause learning (CDCL), building upon DPLL, incorporates additional strategies. The most critical of these is analyzing the cause of conflicts upon encountering an unsatisfiable state. This analysis transforms backtracking into backjumping [12,13], effectively skipping unnecessary local backtracking.

Various CDCL-based solvers achieve further optimization by improving or introducing additional pruning strategies, enhancing the overall efficiency of the solving process.

In both DPLL and CDCL, unit propagation is the most commonly used and essential technique for reducing the search space through pruning [14]. Unit propagation analyzes the clauses affected by existing assignments. If a clause contains only one unassigned literal, that literal is forced to take a value of 1 or 0 to satisfy the clause under the current assignment. This approach avoids blindly selecting variable assignments and significantly accelerates the solving process.

In summary, backtracking determines how to retreat during the search, while unit propagation largely dictates how to advance the search efficiently.

2.1.2. Parallel Algorithms: DAC and Portfolios

Currently, mainstream parallel SAT solving methods can be categorized into two types:

Portfolio-based solving: Tools like ManySAT [15], Hordesat [16], and SArTagnan [17] employ this approach. These methods simultaneously create multiple solving instances using diverse restart [18] and decision strategies. The solving process is completed as soon as the fastest instance finishes.

Divide-and-conquer-based solving: This method, which is the focus of this paper, attempts to accelerate solving by dividing the search space into smaller segments and solving them in parallel. A commonly used method for dividing the search space is guiding paths [19], which is intuitive and straightforward. It assigns variables of 0 or 1 to partition the search space. For instance, assigning $x_1=1$ and $x_1=0$ creates two parallel instances, while assigning $x_2=1$ and $x_2=0$ simultaneously creates four instances.

Figure 2a,b illustrate these two parallel solving strategies.

For Figure 2b (Portfolio Solving), multiple search trees are created, each utilizing different pruning or restart strategies, resulting in varied search paths. Since each tree covers the entire search space, the solving status of the formula can be determined as soon as one tree finds a satisfiable assignment or confirms unsatisfiability.

In contrast, Figure 2a (DAC Solving) demonstrates a single search tree divided into multiple subtrees for parallel solving. Unlike Portfolio Solving, DAC requires all subtrees to confirm unsatisfiability to conclude that the original formula is unsatisfiable. Notably, the computation within each subtree uses sequential algorithms such as CDCL [9], making it possible to combine this method with Portfolio Solving for enhanced performance.

With the increase in computational resources, parallel computing has gradually shifted its focus to leveraging the parallel computing advantages of GPUs [20,21]. Numerous parallel computing methods utilizing GPU acceleration have been continuously proposed.

Although parallel solving may seem straightforward, its core lies in optimizing communication and coordination between instances [21]. Mechanisms such as clause sharing [22] and search path sharing [18] are particularly critical for improving the efficiency of parallel solving.

In summary, DPLL laid the theoretical foundation for SAT solving, but its efficiency is limited by its backtracking and pruning capabilities. CDCL significantly improved single-threaded solving performance through conflict analysis and clause learning, yet it still encounters bottlenecks when handling complex problems. Parallel solving, including portfolio and divide-and-conquer approaches, has greatly enhanced solving capabilities. However, communication and coordination between instances (e.g., clause sharing and path management) remain key challenges affecting parallel efficiency and require further optimization.

2.2. Implementation in Sat Solvers

Traditional SAT solvers are mostly based on the classical DPLL and CDCL algorithms, which explore the solution space step by step through variable assignments and backtracking, and accelerate the solving process using techniques such as conflict-driven clause learning (CDCL). For example, MiniSAT [23], a classic complete solver, is widely used for solving SAT problems and has demonstrated good performance in many practical scenarios. Another complete solver, Z3 [24], was initially designed as an SMT solver, but also performs very well when handling SAT problems. The advantage of complete solvers is that they guarantee finding a solution (if one exists), but their completeness often results in longer solving times when dealing with large-scale or complex SAT instances.

For large-scale or complex problems, full solving is often very difficult, which is why many incomplete solvers use local search and heuristic methods to find approximate solutions, improving solving efficiency. For example, walkSAT [25] uses a randomized local search strategy to quickly find a satisfying solution in the solution space, typically yielding a feasible solution within a short period, although it cannot guarantee finding all solutions. Another incomplete solver, CryptoMiniSat [26], combines randomization and heuristic methods in its search process to optimize solving.

As problem sizes continue to grow, traditional algorithms and solvers, while highly complete, often face computational bottlenecks in certain cases, prompting researchers to explore new solving methods. In this context, the widespread adoption of new technologies such as GPU acceleration and deep learning in SAT solving has been seen in recent years, making them popular research directions today. GPU-accelerated solvers are primarily parallel solvers that fully leverage the advantages of GPU parallel computing, greatly improving the efficiency of solving large-scale problems, especially in hardware verification and artificial intelligence. GPU-based SAT solvers, such as the PicoSAT [27] GPU version, can process massive datasets quickly. At the same time, deep learning techniques have started to be integrated with traditional SAT solving methods, bringing new advances. Solvers like DeepSAT [28] and SATNet [29] optimize search strategies using neural networks and predict variable assignments based on learning from large datasets, reducing backtracking and conflicts. The introduction of deep learning not only enhances solving speed, but also provides new ideas for the intelligence and automation of SAT solvers.

In addition to the solvers mentioned above, many novel solving methods are continuously being researched, and a brief description of these methods is provided in

Table 1. Overview of newest SAT solving methods.

Solving Method	Description
AutoSAT [30]	Optimizes SAT solvers using large language models for automated heuristic selection.
GraSS [31]	Combines Graph Neural Networks and expert knowledge for solver selection.
AlphaMapleSAT [32]	Cube-and-Conquer method enhanced by Monte Carlo Tree Search for complex problems.
HyQSAT [33]	Combines quantum annealing and classical methods for large-scale problem solving.

.

Although different solvers employ cutting-edge technologies, most of them have not completely abandoned the traditional mechanisms of variable assignment and backtracking in their solving principles. New technologies, such as deep learning, primarily serve to assist in optimizing the search process and parameters, making solving more efficient.

3. Search Space and Partitioning

In the previous section, we briefly introduced some SAT solving algorithms, both parallel and sequential. Regardless of the approach, these algorithms ultimately assign values to variables in a step-by-step process, to either find a satisfying assignment for the formula or prove that the original formula is unsatisfiable. We can refer to this solving process as assignment-based solving. In this section, we propose a new solving approach that differs from the traditional assignment-based methods. This approach involves merging variables, which we refer to as abstraction.

To better explain the distinction between abstraction and assignment, we must introduce the concept of search space and intuitively analyze the differences and connections between the two.

3.1. Definition of Search Space

In this study, we use CNF formulas to represent SAT problems. For clarity, we define the following terminology for SAT problems:

• Let $\mathit{F}$ represent a CNF formula and $\mathit{C}$ represent a disjunction. Thus, $\mathit{F}=\{{\mathit{C}}_1,\dots ,{\mathit{C}}_{\mathit{n}}\}$ represents a CNF formula consisting of disjunctions $C_1,\dots ,C_n$, where each $C$ is a clause of the formula F;
• The set of variables appearing in the formula $\mathit{F}$ is denoted as ${\mathit{V}}_{\mathit{F}}$, and the set of variables appearing in a clause is denoted as ${\mathit{V}}_{\mathit{C}}$, represented by $\mathit{x}$;
• To maintain symmetry in the search space, in this paper, we assign the value $\mathit{x}=1$ for true and $\mathit{x}=-1$ for false (instead of x = 0). A set of satisfiable assignments is called a solution to the formula, denoted by $\mathit{S}$, and the set of all solutions is denoted by $\mathit{A}$.

For example, if $C_1=(x_1,x_2)$ and $C_2=(\neg x_1,x_2)$, then $F=\{C_1,C_2\}$ represents the formula $(x_1\vee x_2)\wedge (\neg x_1\vee x_2)$. $S_1=\left\{\mathrm{1,1}\right\}$ and $S_2=\{-\mathrm{1,1}\}$ are two sets of assignments for the formula F, and $A=\{S_1,S_2\}$.

Definition 1.

Given formula $F$, the search space of $F$ is defined as $\left\{X\right|X={\{1,-1\}}^{\left|V_F\right|}\}$, denoted as ${\mathit{Z}}_{\mathit{F}}$.

According to Definition 1, $Z_F$ is the set of vertices of a hyperrectangle centered at the origin, with edges parallel to the coordinate axes. Suppose we have two formulas:

For formula $F_1$, with $\mid V_{F_1}\mid =2$, $A_{F_1}=\{\left(\mathrm{1,1}\right),(1,-1\left)\right\}$.

For formula $F_2$, with $\mid V_{F_2}\mid =3$, $A_{F_2}=\{\left(\mathrm{1,1},1\right),(1,-\mathrm{1,1}\left)\right\}$.

The solutions of these formulas in the search space are shown in Figure 3.

3.2. Assignment-Based Solving and Its Partitioning

3.2.1. Logical Expression of Assignment-Based Solving

As mentioned earlier, in commonly used SAT solving algorithms, variables are assigned values step by step. Assigning a value of 1 to a variable $x_i$ in formula $F$ can be viewed as the formula ${F\wedge x}_i$. Similarly, assigning a value of −1 corresponds to the formula ${F\wedge \neg x}_i$ [9].

Taking the first three formulas in Example 1, ${F=\{C}_1,C_2,C_3\}$, as an example, the result when $x_1=1$ is shown in

Table 2. Results of assigning $x_1=1$ to each clause.

Original Formula	Formula After Assigning
$C_1:x_1\vee x_2\vee x_3$	$C_1\prime :\mathbf{1}\vee x_2\vee x_3$
$C_2:x_1\vee {\neg x}_2$	$C_2\prime :\mathbf{1}\vee {\neg x}_2$
$C_3:x_2\vee x_3$	$C_3\prime :x_2\vee x_3$

.

We can simplify the formula and obtain $F\prime =\left\{\right(\neg x_2),(x_2,x_3\left)\right\}$. Next, we observe the formula $F\wedge x_1$, and the results are shown in

Table 3. Results of each clause when the formula is conjoined with $x_1$.

Original Formula	Formula After Assigning
$C_1:x_1\vee x_2\vee x_3$	$C_1\prime :x_1(Absorption Law)$
$C_2:x_1\vee \neg x_2$	$C_2\prime :\neg x_2\left(Resolution\right)$
$C_3:x_2\vee x_3$	$C_3\prime :x_2\vee x_3$

, where each clause can also be simplified.

The resulting formula is $F″=\{\left(x_1\right),(\neg x_2),(x_2,x_3\left)\right\}$. Assigning $x_1=1$ produces the same results as $F\prime$. Furthermore, in order for the formula $F\wedge x_1$ to be satisfiable, $x_1$ must also be 1.

In other words, logically, the assignment of values to the formula is equivalent to $F\wedge x_i$, and the simplification after assignment is equivalent to applying the absorption law and resolution to the formula $F\wedge x_i$.

At the same time, if the simplified formula $F^{\prime }$ obtained after assigning $x_1=1$ is satisfiable, it indicates that the original formula is also satisfiable. However, if $F^{\prime }$ is unsatisfiable, it does not necessarily imply that the original formula is also unsatisfiable. This can also be explained logically.

Proposition 1.

If the formula $F\wedge \varphi$ is satisfiable, then the formula $F$ is satisfiable.

Proof. 

If $F\wedge \varphi$ is satisfiable, then there exists an assignment $v$ such that $v\left(F\wedge \varphi \right)=True$. $v\left(F\wedge \varphi \right)=True$ is equivalent to $v\left(F\right)=True$ AND $v\left(\varphi \right)=True$. Therefore, if $F\wedge \varphi$ is satisfiable, it implies that $F$ is satisfiable. □

Proposition 2.

If the formula $F\wedge \varphi$ is unsatisfiable, then the formula $F$ is not necessarily unsatisfiable.

Proof. 

If $F\wedge \varphi$ is unsatisfiable, then for all assignments $v$, $v\left(F\wedge \varphi \right)=False$. $v\left(F\wedge \varphi \right)=False$ is equivalent to $v\left(F\right)=False$ OR $v\left(\varphi \right)=False$. This means that it is possible for $F$ to be satisfiable while $F\wedge \varphi$ is unsatisfiable, if $\varphi$ is unsatisfiable under the given assignment. Therefore, the unsatisfiability of $F\wedge \varphi$ does not necessarily imply the unsatisfiability of $F.$ □

Therefore, determining the satisfiability of the original formula by checking whether the simplified formulas for $x_i=1$ and $x_i=-1$ are satisfiable is equivalent to determining the satisfiability of the formula $(F\wedge x_i)\vee (F\wedge \neg x_i)$, which, after simplification, becomes $F$.

From a logical perspective, the assignment-based backtracking algorithm essentially repeats the following steps:

If $F\wedge x_i$ is satisfiable, then $F$ must be satisfiable. To check if $F\wedge x_i$ is satisfiable, one can further check if $F\wedge x_i\wedge x_j$ is satisfiable, and so on.

Similarly, if $F\wedge x_i$ is unsatisfiable, then it is necessary to check if $F\wedge {\neg x}_i$ is satisfiable. To check if $F\wedge {\neg x}_i$ is satisfiable, one can continue checking if $F\wedge {\neg x}_i\wedge x_j$ is satisfiable, progressing step by step.

The search tree of the assignment-based SAT solving algorithm is logically equivalent to the search tree shown in Figure 4.

3.2.2. Partitioning of Assignment-Based Solving

As we learned in the previous section, assignment essentially adds new constraints to the formula. Next, we will explore how these constraints affect the search space.

Definition 2.

Given formulas $F$ and $\varphi$, if $V_{\varphi }\subseteq V_F$, then $\varphi$ is called a logical partition of $F$. The formula $Z_{F\wedge \varphi }$ is referred to as a partition of the search space of $Z_F$, and $F\wedge \varphi$ is called the partitioned formula.

Example 2.

Solving a Formula Using Assignments.

Formula $F$:

$$F=\left\{\left(x_1,x_2,x_3\right),\left(\neg x_1,x_1,x_1\right),\left(x_1,\neg x_2,\neg x_3\right),\left({\neg x}_1,x_2,x_3\right),\left(\neg x_1,\neg x_2,\neg x_3\right)\right\},$$

(5)

If we simulate the assignment process, we first try assigning $x_1=1$ and use unit propagation, which simplifies the formula to:

$$F^{\prime }=\{\left(x_2,\neg x_3\right),\left(x_2,x_3\right),\left(\neg x_2,\neg x_3\right)\},$$

(6)

Next, we assign $x_2=1$, which leaves us with the final clause:

$$F″=\left\{\right(\neg x_3\left)\right\},$$

(7)

Thus, we obtain a satisfiable assignment $S_F=\{\mathrm{1,1},-1\}$.

If we plot the solution and search spaces of the three formulas $F$, $F\prime$, and $F″$, as shown in Figure 5, we can observe the following:

Assigning $x_1=1$ corresponds to using the plane $x_1=1$ to cut the search space $Z_F$, resulting in the space partition $Z_{F\wedge x_1}$.

Assigning $x_2=1$ corresponds to using the line $x_2=1$ to cut the search space $Z_{F\wedge x_1}$, resulting in the partition $Z_{F\wedge x_1\wedge x_2}$.

The entire process involves progressively reducing the dimensions. Each assignment lowers the dimensionality, and when the dimension reaches one, we can check whether the formula has a solution at that point.

As shown in Figure 6, both $x_1$ and $\neg x_1$ partition the formula $F$. They represent the planes $x_1=1$ and $x_1=-1$, respectively. If no solution is found on the plane $Z_{F\wedge {\neg x}_1}$ (the green plane), as seen in the previous search tree, backtracking is used to check for an assignment on $Z_{F\wedge x_1}$ (the blue plane). If no solution is found on either plane, it means that no solution exists within this three-dimensional search space. Similarly, this three-dimensional search space may be derived from a four-dimensional space by partitioning with $x_4$. The next step would involve backtracking to the partition of $\neg x_4$.

Therefore, the backtracking algorithm continuously partitions the search space and ultimately verifies whether a point in the search space is a solution to the formula. Parallel algorithms based on search space partitioning also stem from this backtracking process, but they calculate multiple backtracking paths simultaneously. In addition to this assignment-based search space partitioning, there are other partitioning methods. In this paper, we propose a new search space partitioning method, referred to as abstraction-based search space partitioning.

3.3. Abstraction-Based Solving and Its Partitioning

As mentioned in the previous section, assignment-based solving is essentially solving the two partitioned formulas, $F\wedge x_1$ and $F\wedge \neg x_1$. As long as one of them is satisfiable, the original formula $F$ is satisfiable. This is expressed as follows:

$$F\wedge x_i\vee F\wedge \neg x_i⟺F\wedge \left(x_i\vee \neg x_i\right)⟺F$$

(8)

This conclusion holds for any formula, meaning that:

$$F\wedge \varphi \vee F\wedge \neg \varphi ⟺F$$

(9)

As defined in Definition 1 from the previous section, adding constraints corresponds to partitioning the search space. In other words, $\varphi$ and $\neg \varphi$ are actually methods of partitioning the search space. The constraints added by the assignment, $x_i$ and $\neg x_i$, partition $Z_F$ using the hyperplanes $x_i=1$ and $x_i=-1$, respectively. Each partition reduces the dimensionality by eliminating $x_i$, and through continuous dimensional reduction, a solution is verified.

If we consider dimensional reduction, there are also other methods for reducing dimensions.

Observing the search space partitioning method shown in Figure 7, the search space is partitioned using the planes $x_1=x_2$ (a) and $x_1=-x_2$ (b). In both planes, the dimension $x_3$ is preserved, while the dimensions $x_1$ and $x_2$ are merged into a new dimension. The two planes together form the original search space in its entirety.

We can extend this merging method to higher-dimensional search spaces by partitioning the space with the hyperplanes $x_i=x_j$ and $x_i=-x_j$, effectively merging dimensions $x_i$ and $x_j$ to achieve dimensional reduction. To do this, we need to provide a clear definition of such an operation.

In Answer Set Programming (ASP), researchers have developed a debugging method that maps multiple propositional atoms to a set $\left\{\mathsf{T}\right\}$, which is called Omission-based Abstraction [34]. The merging and dimensional reduction process is similar to this, but instead of omitting atoms, it merges multiple propositional variables and substitutes them with a new variable. Therefore, we can also refer to this operation as abstraction.

Definition 3.

Let $F$ be a formula with $\left|V_F\right|\ge 2$. If the mapping $\{x_m,x_n\}\mapsto \left\{x_t\right\}$ holds, where $x_m,x_n\in V_F$ and $x_t\notin V_F-\left\{x_m\right\}$, the new formula $F\prime$ obtained is called the abstraction of formula $F$, denoted as $F_{(m,n,t)}$.

Abstraction defines the merging of dimensions $x_m$ and $x_n$, with the new dimension denoted as $x_t$. From a logical perspective, the mapping $\{x_m,x_n\}\mapsto \left\{x_t\right\}$ is equivalent to $x_m=x_n(=x_t)$. In Boolean formulas, $x_m=x_n$ is equivalent to ${(x}_m\vee {\neg x}_n)\wedge {(\neg x}_m\vee x_n)$.

As we learned in Section 3.2.1, the simplification of formulas in assignment-based solving is based on resolution and the absorption law. Just as assignments can simplify the original formula, abstraction can also simplify a formula. As shown in

Table 4. The impact of abstraction on clauses.

$\mathbf{Original} \mathbf{Formula} \mathit{F}$	$\mathbf{Formula} \mathbf{After} \mathbf{Abstraction} {\mathit{F}}_{(1,2,0)}$
$C_1:x_1\vee {\neg x}_2\vee x_3$	$C_1^{\prime }:x_0\vee \neg x_0\vee x_3$
$C_2:\neg x_1\vee \neg x_2$	$C_2^{\prime }:\neg x_0\vee \neg x_0$
$C_3:x_2\vee x_3$	$C_3^{\prime }:x_0\vee x_3$
$C_4:{\neg x}_1\vee x_2$	$C_4^{\prime }:{\neg x}_0\vee x_0$

, the simplification of the abstracted formula is also based on resolution.

That is, $F_{(1,2,0)}=\left\{C_2^{\prime },C_3^{\prime }\right\}=\left(\neg x_0\right)\wedge (x_0\vee x_3)$.

The clause $C_1$ and the constraint $(\neg x_1\vee x_2)$ resolve to $x_2\vee {\neg x}_2\vee x_3$, which is equivalent to $C_1^{\prime }$. Similarly, $C_3$ and $(x_1\vee \neg x_2)$ resolve to $x_1\vee x_3$, which is equivalent to $C_3^{\prime }$. We have mapped both $x_1$ and $x_2$ to $x_0$, thus obtaining $C_1^{\prime }$ and $C_3^{\prime }$.

Lemma 1.

$F_{(m,n,t)}⟺F\wedge (x_m=x_n)$.

Now, we have the logical representation of the hyperplane $x_m=x_n$. Since we define False as −1, the symmetry of the search space allows us to use the formula $x_m=\neg x_n$ to represent the plane $x_m=-x_n$. To represent $F\wedge (x_m=-x_n)$, we can generalize extended Definition 3.

In Definition 3, the mapping $F_{(m,n,t)}$, i.e., $\{x_m,x_n\}\mapsto \left\{x_t\right\}$, is essentially a mapping of variables. This includes both $\left[x_m,x_n\right]\mapsto \left[x_t\right]$ and $\left[\neg x_m,\neg x_n\right]\mapsto [\neg x_t]$. Similarly, if we perform such a mapping, $\left[\neg x_m,x_n\right]\mapsto \left[x_t\right]$ and $\left[x_m,{\neg x}_n\right]\mapsto \left[{-x}_t\right]$, we can denote it as $\{{\neg x}_m,x_n\}\mapsto \left\{x_t\right\}$.

Definition 3 (continued).

Let $F$ be a formula with $\left|V_F\right|\ge 2$. If the mapping $\{-x_m,x_n\}\mapsto \left\{x_t\right\}$ holds, where $x_m,x_n\in V_F$ and $x_t\notin V_F-\left\{x_m\right\}$, the new formula $F\prime$ obtained is called the abstraction of formula $F$, denoted as $F_{(-m,n,t)}$.

Similarly, from a logical perspective, this abstraction corresponds to solving $F\wedge (x_m={\neg x}_n)$, which is equivalent to $F\wedge \left(x_m\vee x_n\right)\wedge (\neg x_m\vee \neg x_n)$. As shown in

Table 5. The impact of extended abstraction on clauses.

$\mathbf{Original} \mathbf{Formula} \mathit{F}$	$\mathbf{Formula} \mathbf{After} \mathbf{Abstraction} {\mathit{F}}_{(-2,1,0)}$
$C_1:x_1\vee {\neg x}_2\vee x_3$	$C_1^{\prime }:x_0\vee x_0\vee x_3$
$C_2:\neg x_1\vee \neg x_2$	$C_2^{\prime }:\neg x_0\vee x_0$
$C_3:x_2\vee x_3$	$C_3^{\prime }:{\neg x}_0\vee x_3$
$C_4:{\neg x}_1\vee x_2$	$C_4^{\prime }:{\neg x}_0\vee {\neg x}_0$

, The clauses in $F_{(-m,n,t)}$ also come from the resolution of the original formula’s clauses with $x_m\vee x_n$ or $\neg x_m\vee \neg x_n$, followed by the variable mapping.

That is, $F_{(-2,1,0)}=\left\{C_1^{\prime },C_3^{\prime },C_4^{\prime }\right\}=\left(x_0\vee x_3\right)\wedge \left({\neg x}_0\vee x_3\right)\wedge (\neg x_0)$.

Thus, we can draw similar conclusions.

Lemma 2.

$F_{(-m,n,t)}⟺F\wedge (x_m=\neg x_n)$.

The mapping process represented by abstraction is the merging of dimensions $x_m$ and $x_n$, with the new dimension denoted as $x_t$. This gives us a partitioning method that is different from assignment-based partitioning, namely, abstraction-based partitioning.

The abstraction-based partitioning formulas are as follows: $F\wedge (x_m=x_n)$ or $F\wedge (x_m=\neg x_n)$, which correspond to $F_{(m,n,t)}$ and $F_{(-m,n,t)}$, respectively.

4. Abstraction-Based Solving Method

In this section, we will propose the methodology for abstraction-based solving, drawing on the existing assignment-based solving methods. We will also introduce a hybrid solving method that combines abstraction and assignment.

4.1. Conventional Solving Methods

In Section 3.2.1, we used a search tree to describe the logical form of assignment-based solving. Similarly, abstraction-based solving should also be represented in this manner, as shown in Figure 8.

If the assignment-based solving algorithm is described by the following steps: Assignment → Simplification → Backtracking → Assignment → … then, similarly, the abstraction-based solving algorithm should be divided into these steps: Abstraction → Simplification → Backtracking → Abstraction → …

For the formula $F$, abstraction-based solving can proceed according to the process shown in

Table 6. Abstraction-based solving process.

$\mathit{F}=\left\{\left({\mathit{x}}_1,{\mathit{x}}_2,{\mathit{x}}_3\right),\left({\mathit{x}}_1,{\neg \mathit{x}}_2,{\mathit{x}}_3\right),\left({\mathit{x}}_1,\neg {\mathit{x}}_2,\neg {\mathit{x}}_3\right),\left(\neg {\mathit{x}}_1,{\mathit{x}}_2,{\mathit{x}}_3\right),\left(\neg {\mathit{x}}_1,{\neg \mathit{x}}_2,{\neg \mathit{x}}_3\right),\left(\neg {\mathit{x}}_1,{\neg \mathit{x}}_2,{\mathit{x}}_3\right),\left({\mathit{x}}_1,{\mathit{x}}_2,\neg {\mathit{x}}_3\right)\right\}$
${\mathit{x}}_1={\mathit{x}}_2$ $F^{\prime }=F_{(1,2,2)}=\{\left(x_2,x_3\right),\left(\neg x_2,\neg x_3\right),\left({\neg x}_2,x_3\right),\left(x_2,{\neg x}_3\right)\}$		${\mathit{x}}_1\ne {\mathit{x}}_2$ $F^{\prime }=F_{(-\mathrm{1,2},2)}=\{\left({\neg x}_2,x_3\right),\left(\neg x_2,\neg x_3\right),\left(x_2,x_3\right)\}$
${\mathit{x}}_2={\mathit{x}}_3$ ${F^{\prime }}_{\left(2,3,3\right)}=\{\left(x_3\right),\left(\neg x_3\right)\}$	${\mathit{x}}_2\ne {\mathit{x}}_3$ ${F^{\prime }}_{\left(\mathrm{2,3},3\right)}=\{\left(\neg x_3\right),\left(x_3\right)\}$	${\mathit{x}}_2={\mathit{x}}_3$ ${F^{\prime }}_{\left(\mathrm{2,3},3\right)}=\{\left(\neg x_3\right),\left(x_3\right)\}$	${\mathit{x}}_2\ne {\mathit{x}}_3$ ${F^{\prime }}_{\left(\mathrm{2,3},3\right)}=\left\{\left(x_3\right)\right\}$

.

Only in the final path, where the formula $F$ simplifies to ${F^{\prime }}_{\left(\mathrm{2,3},3\right)}=\left\{\left(x_3\right)\right\}$, does a solution exist, with $x_3=1$. Then, via $x_2\ne x_3$ and $x_2\ne x_1$, we obtain $S=(1,-\mathrm{1,1})$.

In assignment-based solving, each time a variable is assigned a value, its assignment is recorded. In contrast, abstraction-based solving is more like a classifier. Each time an abstraction is performed, variables are divided into two sets based on their equivalence relationships.

For example, if $x_1=x_2$, then the classification is $V_1=\{x_1,x_2\}$, $V_1=\varnothing$.

Then, if $x_2\ne x_3$, we obtain $V_1=\{x_1,x_2\}$, $V_2=\left\{x_3\right\}$.

If $x_3=x_4$, we obtain $V_1=\{x_1,x_2\}$, $V_2=\{x_3,x_4\}$.

This process continues, gradually dividing all variables into two sets, $V_1$ and $V_2$, where any variable $x_i\in V_1$ and $x_j\in V_2$ satisfy $x_i\ne x_j$. The abstraction process eventually leaves variables that represent the assignment of one set, and the assignment for the other set is thereby confirmed. In Table 6, we have $V_1=\{x_1,x_3\}$ and $V_2=\left\{x_2\right\}$.

We can more intuitively observe the solving process in the search space.

The solving steps involve first using the plane $x_1={-x}_2$ to partition $Z_F$, resulting in $Z_{F\wedge x_1=\neg x_2}$, as shown in Figure 9b.

Then, using the line $x_2={-x}_3$, we partition $Z_{F\wedge (x_1=\neg x_2)}$, obtaining $Z_{F\wedge {(x}_1=\neg x_2)\wedge {(x}_2=\neg x_3)}$, as shown in Figure 9c.

Ultimately, the solution is found at the point $x_3=1$.

For assignment-based algorithms, unit propagation is a particularly important strategy. Unit propagation significantly reduces the time spent using the most straightforward backtracking methods [11]. Therefore, abstraction also needs a corresponding strategy to reduce the solving time.

The core of unit propagation involves handling the literals after assignment, ensuring that these literals are true in the formula [10,35]. Similarly, abstraction has a similar process for handling these literals. In all literals, abstraction ensures that all positive literals and negative literals are distinct from each other, while making positive literals equal to each other and negative literals equal to each other. That is to say, if a formula contains $\{\left(x_i\right),\left(x_j\right),\left(\neg x_k\right)\}$, then $x_i=x_j$ and $x_i\ne x_k$.

Since abstraction-based sequential solving is also structured as a tree, abstraction-based parallel solving follows the same implementation approach as assignment-based solving: simultaneously checking multiple subtrees. This will not be further elaborated upon here.

4.2. Hybrid Solving

As seen in the previous section, the abstraction-based solving algorithm ultimately divides $n$ variables into two categories, resulting in $2^{n-1}$ classifications. Therefore, without appropriate strategy optimization, its worst-case time complexity should be $O\left(2^{n-1}\right)$. Its search tree, like that of assignment-based solving, is also a full binary tree. However, the assignment-based approach has already developed many pruning strategies. In the current mature state of assignment-based solving methods, revisiting pruning strategies for abstraction is a cumbersome task. Therefore, a more important approach is to combine the two solving methods.

Although the two methods partition the search space differently, the content within the partitioned search space is the same. In fact, the distribution of solutions within the search space changes, but it still maintains the solutions’ form ${\{1,-1\}}^n$. Therefore, after partitioning the search space using one method, it is still possible to attempt the other method to further partition the search space.

It is worth noting that in assignment-based solving algorithms, the strategy for selecting decision variables, such as VSIDS, plays an important role in the solving time. Some researchers have proven this [36]. Therefore, different strategies for variable selection are also expected to have different impacts on hybrid solving methods.

Thus, we conducted the following experiment:

• Generate a random CNF formula with 350 variables and 4.2 times the number of variables for the number of clauses;
• Use abstraction on variables from randomly selected clauses of length-2 to partition the search space into two parts, referred to as Space R1 and Space R2;
• Use the two most frequently occurring variables in pairs for abstraction to partition the search space into two parts, referred to as Space F1 and Space F2;
• Solve the four search spaces, as well as the original formula, using Minisat;
• Statistical solving times are organized in the table, as shown in

  Table 7. Solving times for different search spaces with Minisat solver (in seconds).

  Problem No.	Satisfiability	Space F1	Space F2	Space R1	Space R2	Origin
  1	UNSAT	−555.21 1	−146.45	−212.80	−490.47	−729.33
  2	UNSAT	−310.68	−59.56	−132.57	−144.30	−300.40
  3	UNSAT	−51.88	−171.60	−82.79	−76.52	−203.23
  4	UNSAT	−151.21	−57.19	−92.22	−60.70	−142.18
  5	UNSAT	−56.58	−87.45	−57.36	−52.51	−131.33
  6	UNSAT	−41.85	−133.15	−56.56	−59.82	−105.52
  7	UNSAT	−92.91	−13.80	−32.58	−36.26	−83.24
  8	SAT	−94.48	293.67	−64.49	174.73	301.19
  9	SAT	39.29	−375.49	−291.77	224.58	100.74
  10	SAT	57.38	−31.86	35.26	25.60	58.33
  11	SAT	74.40	−26.42	57.87	20.30	55.40
  12	SAT	12.80	3.93	−139.53	33.46	44.24
  13	SAT	98.18	3.87	7.56	4.89	23.80
  14	SAT	11.72	17.81	108.16	11.07	23.57
  15	SAT	53.56	15.34	119.94	29.18	22.53
  16	SAT	1.10	1.79	153.15	0.08	10.14
  17	SAT	11.63	−62.29	5.70	−41.93	7.45
  18	SAT	3.22	5.66	1.41	0.25	6.07
  19	SAT	1.80	3.48	102.24	1.08	2.38
  20	SAT	7.61	8.78	0.96	8.59	2.08

  ¹ The solving time marked with a negative value indicates that there is no satisfiable solution within that search space.

  .

If the two search spaces partitioned through abstraction are solved using a simple DAC parallel solving approach, then when the formula is satisfiable, the solving time should be the minimum value from the two search spaces. When the formula is unsatisfiable, the solving time should be the maximum value from the two search spaces. The impact of different strategies on the solving time is shown in Figure 10.

It can be observed that, when the formula is satisfiable, Strategy R tends to accelerate solving. When the formula is unsatisfiable, Strategy F is more effective in speeding up the solving process. In addition to the samples above, the experiment calculated a total of 100 CNF formulas, 38 of which are unsatisfiable. In 81% of these cases, Strategy F accelerated solving; for the remaining 62 formulas, Strategy R accelerated solving in 72% of cases. Considering that this is a simple parallel method, the probability of improving computational efficiency should be higher in more advanced parallel algorithms.

To examine the impact of the number of variables or clauses on abstract hybrid solving, we controlled the number of variables or clauses while changing the other factor. The results are shown in Appendix A.1. The solver used in the above experiments is MiniSat. To investigate the impact of abstraction on different solvers, we also tested other solvers, with the test data sourced from SAT competition 2024. The data obtained from these tests are shown in Appendix A.2.

All these experiments led to a similar conclusion: abstract hybrid solving can optimize solving time in most cases.

Analyzing the reason behind this, we believe that the main factor is that abstraction alters the length of certain clauses. This affects the unit propagation process, which, as emphasized earlier, is crucial for solving performance [10].

If Strategy R is used, where variables in length-2 clauses are abstracted, single literals are produced, allowing unit propagation to occur. If Strategy F is used, where the most frequently occurring variable pairs are selected for abstraction, clauses that were originally length-3 become length-2, enabling unit propagation in a process where it would otherwise be impossible.

Take formula $\{\left(x_1,x_3\right),\left(\neg x_1,x_4,x_5\right),\left(x_3,x_4,x_6\right),(\neg x_4,\neg x_6,\neg x_5\left)\right\}$ as an example, abstraction is applied using two strategies. From Figure 11, it can be observed that in Strategy R, the new clause $C_1$ produced by abstraction participates in the unit propagation process. In Strategy F, the original clause $C_4$ changes from $(\neg x_4,\neg x_6,\neg x_5)$ to $(\neg x_0,\neg x_5)$, allowing clause $C_5$ to determine the variable assignments in $C_4$ through unit propagation, continuing the influence of unit propagation.

Similarly, both strategies can lead to the removal of clauses directly from the formula, and these removed clauses might have participated in unit propagation in the original assignment-based solving algorithm.

One of the other effects of reducing clause length is its impact on backtracking. For example, consider the following formula:

$$\begin{gathered} F=\{\left(x_2,x_4\right),\left(\neg x_2,\neg x_3\right),\left({\neg x}_2,x_4\right),\left({\neg x}_4,x_2,x_3\right),\left(x_1,\neg x_2,x_3,x_4\right),\left(x_3,\neg x_4\right), \\ \left({\neg x}_2,x_3,x_4\right),\left({\neg x}_4,\neg x_1,x_2\right)\} \end{gathered}$$

When solving this formula using the assignment-based method, four backtrack operations are performed, and the paths are shown in Figure 12.

If we first perform abstraction on the formula, we obtain the following:

$$F_{(\mathrm{1,2},2)}=\left\{\left(x_2,x_4\right),\left(\neg x_2,\neg x_3\right),\left({\neg x}_2,x_4\right),\left({\neg x}_4,x_2,x_3\right),\left(x_3,\neg x_4\right),\left({\neg x}_2,x_3,x_4\right)\right\}$$

As shown in Figure 13, when solving the abstracted formula $F_{(\mathrm{1,2},2)}$ using the assignment-based method, only two backtrack operations are performed, and the depth of each backtrack is not deep.

As mentioned in Section 2.1, backtracking determines how to retreat during the search, while unit propagation primarily determines how to advance the search. Abstraction impacts both of these processes, causing some calculations to speed up and others to slow down in algorithms that combine abstraction and assignment. Therefore, compared to DAC, it might be more worthwhile to try incorporating abstraction as a new strategy into portfolio-based parallel solving methods.

Additionally, abstraction can also be useful in SMTs (Satisfiability Modulo Theories) [37]. SMTs refer to more complex constraint problems that build on traditional SAT problems by introducing additional theoretical constraints, such as arithmetic, strings, and matrices, etc. [37,38,39]. As a result, solving SMT problems is divided into two parts: the SAT solver and the theory solver, often referred to as DPLL(T) [40].

The SAT solver is used to obtain feasible atomic assignments, while the theory solver checks these atomic assignments. If they are not feasible, the theory solver feeds back to the SAT solver for further adjustments.

For example, consider the expression $(y-x>3)\vee (x>e^y-e)\vee \dots$

In SMTs, these details are initially ignored, and the formula is treated as a propositional formula $a\vee b\vee \dots$ The solver first solves it, for instance by assigning $a=1$ and $b=1$, and then passes these assignments to the theory solver to check if they satisfy the constraints. This means checking if $y-x>3$ holds, and simultaneously ensuring that $x>e^y-e$ also holds. If the assignments do not satisfy the constraints, the theory solver returns $\neg a\vee \neg b$, and the SAT solver continues the search. This iterative process continues until a solution is found.

The abstraction proposed in this paper is actually based on atomic equivalence relations, such as $a=b$ or $a\ne b$. From the perspective of abstraction, whether certain variables are equal or not can simplify the formula. In the formula $y-x>3$ and $x>e^y-e$, it is clear that they cannot both hold simultaneously. Therefore, we can conclude that $a\ne b$, which allows for the further simplification of the formula. This approach can also be used to assess the satisfiability of SMT problems using abstraction.

In other words, through the theory solver, we can pre-determine the equivalence of certain atoms. By integrating abstraction into the SMT solver, we can simplify the formula based on these equivalences before continuing with the solving process.

4.3. Summary of Abstraction-Based Solving

In the previous section, we explained step by step how the abstraction-based SAT solving algorithm is implemented. In this subsection, we will briefly review the entire solving process and highlight the differences between it and the assignment-based solving approach.

Compared to traditional assignment-based solving, the main difference with abstraction-based solving is that it does not assign values to propositional atoms. Instead, it classifies the propositional atoms. If we continued abstraction to its extreme, where all atoms are classified into two categories, it would essentially become a purely abstraction-based algorithm. However, if abstraction is carried out to a certain extent and then an assignment-based algorithm is used, it becomes a hybrid solving method. As shown in Figure 14, the relationship between the two approaches is clear.

As shown in Figure 14a, when only using the assignment-based solving method, the result will be the variable assignments. If only the abstraction-based solving method is used, the result will be two sets of different variables, as depicted in Figure 14c. However, when using the hybrid solving method, the result will include both the two sets of different variables and the assignments of certain elements within those sets, as shown in Figure 14b.

So far, we have outlined the specific methods and implementation steps for abstraction, as well as its potential benefits. However, during our actual solutions, we still encountered some issues.

Although the experimental data suggest that abstract hybrid solving can accelerate the solving process in most cases, they also indicate that in certain situations, the efficiency of abstract hybrid assignment solving is not as good as when directly using assignment-based solving. In fact, the time consumed may even be significantly higher than that of direct solving.

As mentioned in the experiments, the selection of abstract variables plays a crucial role in the solving process. However, to date, there is no optimal strategy for choosing variables for abstraction. The two strategies used in the experiments are among the simplest and most straightforward.

Additionally, the experiments were conducted by first performing abstraction just once and then solving. How to integrate abstraction with the existing solvers and establishing communication between the two methods are areas that require further research.

Finally, the method still lacks the corresponding strategies when dealing with large-scale problems, as the cost of certain abstraction strategies, such as identifying the most frequent pairs of variables, increases with problem size.

5. Unified Method for Search Space Partitioning

Below, we have listed the logical expressions for solving based on assignment and abstraction:

Assignment: $F\wedge x_i\vee F\wedge \neg x_i$.

Abstraction: $F\wedge (x_m=x_n)\vee F\wedge (x_m\ne x_n)$.

The logical formulas $x_i$ and $x_m=x_n$ represent a partition of the search space, while their counterparts $\neg x_i$ and $x_m=x_n$ are complementary partitions. As we mentioned in Section 3.3, Formula (9): $F\wedge \varphi \vee F\wedge \neg \varphi ⟺F$.

If we simplify the formula, we obtain $F\wedge (\varphi \vee \neg \varphi )$, which simplifies to $F\wedge 1$, thus demonstrating that satisfiability entirely depends on the formula $F$.

In fact, we can give a unified definition for such a partition of the search space.

Definition 4.

Given a formula $F$, if ${\varphi }_1$, ${\varphi }_2$, …, ${\varphi }_n$ are logical partitions of $F$ respectively, then ${\varphi }_1$, ${\varphi }_2$, …, ${\varphi }_n$ are called a set of logical partitions of $F$. $\underset{i=1}{\overset{n}{\bigvee }}(F\wedge {\varphi }_i)$ is called the partition formula, and $F\wedge {\varphi }_i$ is called the subpartition formula. If $\underset{\mathit{i}=1}{\overset{\mathit{n}}{\bigvee }}{\mathit{\varphi }}_{\mathit{i}}=1$, then ${\varphi }_1$, ${\varphi }_2$, …, ${\varphi }_n$ are called a set of complete logical partitions of $F$.

From Proposition 1, it is known that, regardless of whether a set of partitions is complete, as long as there is a solution in any partition, the original formula must have a solution.

Theorem 1.

If ${\varphi }_1$, ${\varphi }_2$, …, ${\varphi }_n$ are a set of logical partitions of $F$, and the partition formula is satisfiable, then $F$ is satisfiable.

Theorem 1 only guarantees the sufficiency that if the partition formula is satisfiable, then the original formula is satisfiable. The advantage of a complete partition is that it not only provides the necessary condition, but also shows the situation where the original formula has no solution.

Theorem 2.

If ${\varphi }_1$, ${\varphi }_2$, …, ${\varphi }_n$ are a set of complete logical partitions of $F$, then $F$ is unsatisfiable if and only if the partition formula is unsatisfiable, and $F$ is satisfiable if and only if the partition formula is satisfiable.

Proof. 

Let the set of partitions be ${\varphi }_1$, ${\varphi }_2$, …, ${\varphi }_n$, and let $Q={\varphi }_1\vee {\varphi }_2\vee {\dots \vee \varphi }_{\mathrm{n}}$.

The partition formula is as follows:

$$(F\wedge {\varphi }_1)\vee (F\wedge {\varphi }_2)\vee \cdots \vee (F\wedge {\varphi }_n)⟺F\wedge ({\varphi }_1\vee {\varphi }_2\vee {\dots \vee \varphi }_n)⟺F\wedge Q$$

(10)

1.

Consistency of Unsatisfiability:

Sufficiency: If $F$ is unsatisfiable, since it is a set of complete partitions, $Q=1$. Thus, $F\wedge Q⟺F\wedge 1⟺F$ is unsatisfiable. Therefore, $(F\wedge {\varphi }_1)\vee (F\wedge {\varphi }_2)\vee \cdots \vee (F\wedge {\varphi }_{\mathrm{n}})$ is unsatisfiable, i.e., for any ${\varphi }_{\mathrm{i}}$, $F\wedge {\varphi }_{\mathrm{i}}$ is unsatisfiable.

Necessity: If for any ${\varphi }_{\mathrm{i}}$, $F\wedge {\varphi }_{\mathrm{i}}$ is unsatisfiable, the partition formula $(F\wedge {\varphi }_1)\vee (F\wedge {\varphi }_2)\vee \cdots \vee (F\wedge {\varphi }_{\mathrm{n}})$ is unsatisfiable. Hence, $F\wedge Q$ is unsatisfiable, since $Q=1$. Therefore, $F$ is unsatisfiable.

2.

Consistency of Satisfiability:

Sufficiency: If $F$ is satisfiable, since $Q=1$, then $F\wedge Q⟺1\wedge 1⟺1$. Therefore, $(F\wedge {\varphi }_1)\vee (F\wedge {\varphi }_2)\vee \cdots \vee (F\wedge {\varphi }_{\mathrm{n}})$ is satisfiable. Hence, there exists some ${\varphi }_{\mathrm{i}}$ such that $F\wedge {\varphi }_{\mathrm{i}}$ is satisfiable, which implies that if $F$ is satisfiable, the partition formula is satisfiable.

Necessity: If the partition formula is satisfiable, this is equivalent to Theorem 1. □

At the same time, when describing the partitions based on assignment and abstraction, we mentioned that the two partitions are composed of complementary formulas. If we make a strict definition, we can further formalize the partitions.

Definition 5.

Given a formula $F$, if ${\varphi }_1$, ${\varphi }_2$, …, ${\varphi }_n$ are logical partitions of $F$, then ${\varphi }_1$, ${\varphi }_2$, …, ${\varphi }_n$ are called a set of logical partitions of $F$, $\underset{i=1}{\overset{n}{\bigvee }}(F\wedge {\varphi }_i)$ is called the partition formula, and $F\wedge {\varphi }_i$ is called the subpartition formula. If for any $i,j\le n$ and $i\ne j$, ${\mathit{\varphi }}_{\mathit{i}}\wedge {\mathit{\varphi }}_{\mathit{j}}=-1$, then ${\varphi }_1$, ${\varphi }_2$, …, ${\varphi }_n$ are called a set of independent logical partitions of $F$.

The completeness of the partitions ensures that this set of partitions can reveal the satisfiability of the formula, while the independence of the partitions helps identify which partition the solution falls into when the formula is satisfiable.

Theorem 3.

If ${\varphi }_1$, ${\varphi }_2$, …, ${\varphi }_n$ are a set of independent complete logical partitions of $F$, and $F$ is satisfiable, then for every solution $S$, there exists exactly one logical subpartition ${\varphi }_i$ such that the subpartition formula ${S(F\wedge \varphi }_i)=1$.

Proof. 

Let the set of partitions be ${\varphi }_1$, ${\varphi }_2$, …, ${\varphi }_n$, and let $Q={\varphi }_1\vee {\varphi }_2\vee {\dots \vee \varphi }_{\mathrm{n}}$, a solution $S$.

The partition formula is as follows:

$$(F\wedge {\varphi }_1)\vee (F\wedge {\varphi }_2)\vee \cdots \vee (F\wedge {\varphi }_n)⟺F\wedge ({\varphi }_1\vee {\varphi }_2\vee {\dots \vee \varphi }_n)⟺F\wedge Q$$

(11)

From completeness, we know that $Q=1$.

Thus, $S\left(F\right)=S\left(F\wedge 1\right)=S\left(F\wedge Q\right)=1$. Therefore, $(F\wedge {\varphi }_1)\vee (F\wedge {\varphi }_2)\vee \cdots \vee (F\wedge {\varphi }_{\mathrm{n}})$ is satisfiable and there exists some ${\varphi }_i$ such that $S({F\wedge \varphi }_i$) = 1.

Now, assume that another subpartition ${\varphi }_j$ exists, such that $S(F\wedge {\varphi }_i)=1$.

Therefore, $S\left(\left({F\wedge \varphi }_i\right)\vee \left(F\wedge {\varphi }_i\right)\right)=S({F\wedge (\varphi }_i\vee {\varphi }_i))=1$. Thus, $S({\varphi }_j\wedge {\varphi }_i)=1$.

From the independence of the partitions, we know that ${\varphi }_j\wedge {\varphi }_i=-1$, which leads to a contradiction. Therefore, there can only exist one subpartition ${\varphi }_i$, such that the subpartition formula is satisfiable. □

According to the pigeonhole principle, we know that for any three Boolean variables, there must be two variables with the same assignment. That is,

$$\left(x_i=x_j\right)\vee \left(x_j=x_k\right)\vee \left(x_k=x_i\right)=1$$

(12)

If we consider these three logical formulas as a set of logical partitions, then this set of partitions is complete, and its partition formula is as follows:

$$\left({F\wedge x}_i=x_j\right)\vee \left({F\wedge x}_j=x_k\right)\vee \left({F\wedge x}_k=x_i\right)$$

(13)

However, the conjunction of any two logical partitions is satisfiable, meaning that they are not independent logical partitions. When solving the first search space, solutions in other search spaces will repeat previously verified solutions. For example, when searching the space of $Z_{{F\wedge x}_j=x_k}$, some solutions satisfying $x_i=x_j$ will also be searched.

From the search space, we can see that, for example, in three dimensions, the planes $x_1=x_2$, $x_2=x_3$, $x_1=x_3$ will all pass through the line $x_1=x_2=x_3$ in the space. This line may contain some solutions, causing the search on each plane to repeatedly verify these assignments.

In contrast, in the assignment-based partition, each plane does not intersect, and is thus independent. In the abstraction-based partition, since each plane intersects at the coordinate axes, and no points from the search space lie on the axes, this partition is also independent.

In some local search algorithms, the algorithm assigns values to multiple variables at once [41,42]. If we use partitions, this form can be represented by the following logical formula:

$$F\wedge x_i\wedge \neg x_j\wedge \cdots \wedge x_n⟺F\wedge {\varphi }_1$$

(14)

where ${\varphi }_1=x_i\wedge \neg x_j\wedge \cdots \wedge x_n$ represents one term of the Principal Disjunctive Normal Form (PDNF) constructed from $x_i\wedge \neg x_j\wedge \cdots \wedge x_n$, and it, along with the other terms of this PDNF, forms a set of independent complete logical partitions of $F$. Independence ensures that the assignments already checked do not need to be checked again, while completeness guarantees that the satisfiability of the formula can eventually be determined.

Assuming that $\left|V_{{\varphi }_1}\right|=t$, this partition divides the search space into $2^t$ equally sized search spaces. $F\wedge {\varphi }_1$ checks only one of these, while $F\wedge \neg {\varphi }_1$ contains the remaining $2^t-1$ search spaces. By flipping a literal in ${\varphi }_1$, we obtain a term from $\neg {\varphi }_1$. From Theorem 2, it can be deduced that to determine satisfiability, each remaining search space must be checked individually, which requires exponential time. Therefore, local search algorithms often flip certain variables based on the satisfiability of clauses [36,43], meaning that they selectively solve within the remaining search space.

In addition, in parallel SAT algorithms, there is another type of search space partition called XOR partition [10,43].

$$F_{even}=F\wedge \left(x_1\oplus x_2\oplus \dots x_n\oplus 1\right)$$

(15)

$$F_{odd}=F\wedge \left(x_1\oplus x_3\oplus \dots x_n\oplus 0\right)$$

(16)

This partition is also independent and complete, and it is equivalent to the abstraction-based partition when there are only two variables.

$$FF\wedge \left(x_1\oplus x_2\oplus 1\right)\iff F\wedge \left(x_1=x_2\right)$$

(17)

$$F\wedge \left(x_1\oplus x_2\oplus 0\right)\iff F\wedge \left(x_1=\neg x_2\right)$$

(18)

Through analysis of the partitions, we can conclude that, in addition to mixing abstraction-based and assignment-based solving, different solving algorithms can also be combined, as long as the partitions they correspond to are independent and complete. This ensures both consistency between the satisfiability of all search spaces and the satisfiability of the original formula, while avoiding redundant calculations.

6. Conclusions

This paper analyzes the solving process of the SAT problem from the perspective of search space. It defines the search space and its partitioning from both topological and logical perspectives, and explains their relationship: logical partitions can be represented as certain hyperplanes in a topological space. This conclusion connects the geometric meaning of SAT problem solving in topological spaces with logical operators and may provide a different perspective for solving the SAT problem.

The paper then analyzes the search space partitioning in assignment-based solving and proposes a new search space partitioning method, called abstraction. Using the steps of assignment-based solving as a reference, the steps for abstraction-based solving and their hybrid solving process are defined. Experimental data show that hybrid solving using both abstraction and assignment can accelerate solving in most cases. By combining more different search space partitions and studying the situations that are suitable for these partitions, a new direction can be provided for improving the efficiency of SAT problem solving.

Finally, the paper also presents a unified method for search space partitioning, defining the meanings of independent partitions and complete partitions, and explaining how some existing algorithms perform partitioning. This demonstrates that search space partitioning is, in fact, an effective method for improving the efficiency of SAT problem solving.

In future work, one key area to focus on is researching suitable abstraction strategies that can significantly reduce solving time and cope with large-scale problems. As mentioned earlier, combining abstraction with assignment-based solving is worth exploring more than directly using abstraction alone. Therefore, another important aspect is to study how to integrate abstraction and assignment, developing a solving strategy that can automatically determine when to use assignment-based simplification and when to use abstraction-based simplification, and then implement a corresponding solver.