Characterization of Glue Variables in CDCL SAT Solving

TL;DR

This paper investigates glue clauses in CDCL SAT solving, revealing that glue variables are more inference-efficient and proposing a structure-aware variable bumping method that improves solver performance.

Contribution

It introduces the concept of glue variables, links them to decision variables, and develops a novel bumping scheme that enhances CDCL solver efficiency.

Findings

Glue variables lead to more efficient inferences and conflicts.

The proposed bumping scheme improves solver performance on benchmark instances.

Glue clauses are highly influential in the search process.

Abstract

A state-of-the-art criterion to evaluate the importance of a given learned clause is called Literal Block Distance (LBD) score. It measures the number of distinct decision levels in a given learned clause. The lower the LBD score of a learned clause, the better is its quality. The learned clauses with LBD score of 2, called glue clauses, are known to possess high pruning power which are never deleted from the clause databases of the modern CDCL SAT solvers. In this work, we relate glue clauses to decision variables. We call the variables that appeared in at least one glue clause up to the current search state Glue Variables. We first show experimentally, by running the state-of-the-art CDCL SAT solver MapleLCMDist on benchmarks from SAT Competition-2017 and 2018, that branching decisions with glue variables are categorically more inference and conflict efficient than nonglue variables. Based on this observation, we develop a structure aware CDCL variable bumping scheme, which bumps the activity score of a glue variable based on its appearance count in the glue clauses that are learned so far by the search. Empirical evaluation shows effectiveness of the new method over the main track instances from SAT Competition 2017 and 2018.

Figures

Tables

Table 1. Table 1 : Comparison of average of PR, LR and avg. LBD of glue and nonglue decisions.

Type	#Instance	Glue Decisions Average			NonGlue Decisions Average
		PR	LR	aLBD	PR	LR	aLBD
Satisfiable	235	309.58	0.47	31.76	61.42	0.19	40.55
Unsatisfiable	207	417.49	0.59	12.82	65.84	0.27	30.10
Unsolved	308	385.08	0.52	24.23	153.39	0.37	34.09
Overall	750	371.21	0.52	23.29	100.46	0.29	35.02

Algorithm 1: Increase Glue Level	Algorithm 2: Bump Glue Variable
Input: A newly learned glue clause $g$	Input: A glue variable $v_g$
1    For $i\leftarrow 1to\left|g\right|$ 2       $v_g\leftarrow varAt(g,i)$ 3       $gl\left(v_g\right)\leftarrow gl\left(v_g\right)+1$ 4    End	1  $gc\left(v_g\right)\leftarrow \frac{gl\left(v_g\right)}{{\forall }_{v_{g^{\prime }}\in vars\left(G\right)}\sum gl\left(v_{g^{\prime }}\right)}$                     2  $bf\leftarrow activity\left(v_g\right)\ast gc\left(v_g\right)$                     3  $activity\left(v_g\right)\leftarrow activity\left(v_g\right)+bf$

Table 3. Table 2 : Comparisons for the main track instances from SAT-2017, 2018.

Problems Sets	Systems
	(A) MLD			(B) ${\mathrm{𝐌𝐋𝐃}}^{\mathrm{𝐠𝐛}}$			(C) MLD_CBT			(D) $\mathrm{𝐌𝐋𝐃}\_{\mathrm{𝐂𝐁𝐓}}^{\mathrm{𝐠𝐛}}$
	Sat	Unsat	PAR-2	Sat	Unsat	PAR-2	Sat	Unsat	PAR-2	Sat	Unsat	PAR-2
SAT-17	99	106	1635712.64	99	107	1645635.64	103	113	1565640.80	107	111	1523343.19
SAT-18	136	101	1807074.6	139	102	1770015.2	135	102	1800012.20	134	101	1815868.62
Overall	235	207	3442787.24	238	209	3415650.6	238	215	3365653	241	212	3339211.81
	442			447			453			453

Table 4. (a) Table 3: Inference and Conflict Efficiency Comparison

System	PR (A)	GLR (B)	Average LBD (C)
MapleLCMDist	158.31	0.40	27.73
MapleLCMDistgb	160.25	0.40	27.56

Table 5. (a) Table 3: Inference and Conflict Efficiency Comparison

System	PR (A)	GLR (B)	Average LBD (C)
MapleLCMDist	158.31	0.40	27.73
MapleLCMDistgb	160.25	0.40	27.56

Table 6. (b)     Table 4: Comparison of Glue Decision Measures.

System	#gd (A)	Average over Glue Decisions
MapleLCMDist	26.8 M	PR (B)	LR (C)	average LBD (D)
		371.21	0.52	23.29
MapleLCMDistgb	28 M	370.49	0.52	22.63

Full text

1 Introduction

SAT is known to be NP-complete [3]. Despite the hardness, modern CDCL SAT solvers routinely solve large real world instances with thousands of variables and millions of clauses with surprising efficiency. This is the result of elegant mashup of its key components, such as preprocessing/inprocessing, robust branching heuristics, efficient restart policies, intelligent conflict analysis, and effective clause learning [2].

Clause learning facilitates search by pruning the search space. However, since a clause learning CDCL solver learns clauses at a very high rate and a large amount of learned clauses may reduce the overall performance, clause database management has become another key component of modern CDCL SAT solving, which periodically reduces the learned clause database by keeping only the most relevant ones [11].

Before the CDCL SAT solver Glucose [1], size and recent activity of the learned clauses were the dominant criteria for determining relevance of learned clauses [4]. Glucose proposed a new measure named Literal Block Distance (LBD) score, which measures the number of distinct decision levels in a learned clause. Glucose (as well as some other modern CDCL SAT solvers) permanently stores a special type of learned clauses, called glue clauses, which have LBD score of 2. A glue clause connects, under the current partial assignment, a literal from the current decision level with the block of literals propagated in a previous decision level. As a glue clause connects a block of closely related variable, a relatively small number of decisions are needed to activate (i.e., making it unit) that glue clause in the future. Thus learning of a glue clause may cause relatively higher number of propagations and faster generation of conflicts within fewer numbers of decisions. Simply put, glue clauses have more potential to reduce the search space more quickly than other learned clauses with higher LBD scores.

Inspired by the intuitive characteristics of glue clauses, we ask the following question: Can glue clauses be used to help re-rank decision variables to improve search efficiency? To address this question, we consider two types of variables, glue variables, the ones that have appeared in at least one glue clause up to the current search state and nonglue variables that have not. The main contributions of this paper are:

• •

We conduct an experiment using the instances from the main track of SAT Competition 2017 and 2018 (abbreviated as SAT-2017 and SAT-2018, respectively) with the CDCL SAT solver MapleLCMDist. First, our experiment shows that decisions with glue variables are categorically more inference and conflict efficient than nonglue variables. Secondly, comparing with nonglue variables, glue variables are picked up by the branching heuristics of MapleLCMDist disproportionately more often.

• •

The above results motivated us to design a structure-aware variable score bumping method named Glue Bumping (GB), based on the notion of glue centrality of glue variables, which dynamically measures the occurrence count of a glue variable relative to the occurrence count of all the glue variables discovered so far by the search. This differs from the score bumping in Glucose [1], which increases the scores of variables in a learned clause that were propagated by a glue clause. Our idea is to bump the activity score of a glue variable based on its glue centrality score, encouraging the CDCL branching heuristics to branch more often on recently active high centrality glue variables. We implement the GB method on top of MapleLCMDist (winner of SAT-2017) and MapleLCMDistChronoBT (winner of SAT-2018). Our GB extensions achieve lower PAR-2 scores than the baselines over the instances from SAT-2017 and SAT-2018, which shows the effectiveness of the new method.

2 Notations

Let $\mathcal{F}$ be a SAT formula and $vars_{\mathcal{F}}$ the set of variables in $\mathcal{F}$. Suppose a CDCL solver $M$ is solving $\mathcal{F}$ and $s$ is the current search state. At $s$, $M$ has taken $\#d>0$ decisions, generated $\#p\geq 0$ propagations, $\#c\geq 0$ conflicts, and learned $\#g\geq 0$ glue clauses. We denote the set of these $g$ glue clauses by $G$. We define Propagation Rate (PR), Learning Rate (LR) over $\#d$ decisions as $\frac{\#p}{\#d}$ and $\frac{\#c}{\#d}$, respectively.

Let $vars_{G}$ be the set of glue variables appearing in $G$ and $vars_{NG}=vars_{\mathcal{F}}\setminus vars_{G}$ be the set of nonglue variables. We define Glue Level, denoted $gl(v_{g})$, of a glue variable $v_{g}$ as the number of glue clauses in $G$ in which $v_{g}$ appears. Glue Centrality for the glue variable $v_{g}$, denoted by $gc_{v_{g}}$, is the ratio of its glue level and the combined glue level of all glue variables in $vars_{G}$, i.e., $gc(v_{g})=\frac{gl(v_{g})}{\forall_{v_{g}^{\prime}\in vars_{G}}\sum gl(v_{g}^{\prime})}$.

A Glue Decision is the branching decision that selects a glue variable to branch on. Similarly, a NonGlue Decision is the branching decision that selects a nonglue variable to branch on. Suppose $M$ has taken $\#gd\leq\#d$ glue decisions and $\#ngd\leq\#d$ nonglue decisions until $s$. We define Glue variable Fraction (GF) (resp. NonGlue variable Fraction (NGF) ) as $\frac{|vars_{G}|}{|vars(\mathcal{F})|}$ (resp. $\frac{|vars_{NG}|}{|vars(\mathcal{F})|}$), which denotes the fraction of variables in $\mathcal{F}$, which are glue (resp. nonglue ) variables until $s$.

3 Experiment with Glue Variables

In this section, we report experimental results regarding the role of glue variables in a CDCL solving process. The CDCL solver in this experiment is MapleLCMDist, which uses a combination of three CDCL heuristics VSIDS [10], LRB [7], and Dist [12].

We run all 750 instances used in the main track of SAT-2017 (350 instances) and 2018 (400 instances) with 5000 seconds timeout limit per instance. We slightly modified MapleLCMDist to collect the following statistics for each instance: (i) the numbers of glue and nonglue decisions, (ii) PR, LR, average LBD for both glue and nonglue decisions, and (iii) GF/NGF. All the experiments are run on a Linux workstation with 64 GigaBytes RAM and processor clock speed of 1.2 GHZ.

Inference and Conflict Generation Power of Glue Variables: Table 1 shows a comparison of average PR, LR and average LBD for glue and nonglue decisions, grouped by satisfiable, unsatisfiable and unsolved instances. Compared to the nonglue decisions, on average, MapleLCMDist achieves significantly higher PR (overall almost 4 times higher), LR (overall, almost twice as high) and lower average LBD (overall, almost 1.5 times lower) with the glue decisions.

Figure 1 shows the PR (left), LR (middle) and average LBD (right, in log scale) values for both glue and nonglue decisions. Clearly, these three plots in this figure accurately reflects the average values of PR, LR and average LBD in Table 1. For almost all the instances glue decisions achieve higher PR and LR compared to nonglue decisions. Compared to the nonglue decisions, the average LBD score of the clauses which are learned from the conflicts generated with glue decisions is lower for almost all the instances. Thus glue decisions are categorically more inference and conflict efficient than nonglue decisions.

Selection Bias of Glue Variables: A question arises as whether conflict guided CDCL branching heuristics exhibit any bias towards glue variables over nonglue variables.

The average value of the number of glue decisions ($\#gd$) and the number of nonglue decisions ($\#ngd$) over the 750 instances are 26857888.34 (> 26.8 M) and 32007216.51 (>32 M), respectively. The average GF (glue variable Fraction) and NGF (nonglue variable Fraction) values over these 750 instances are 0.22 and 0.78, respectively. Thus, on average, from a $\frac{0.78-0.22}{0.22}*100=254.54\%$ bigger pool, on average, nonglue variables are selected only $\frac{32007216.51-26857888.34}{26857888.34}*100=19.17\%$ more often than glue variables. Hence, CDCL heuristics exhibits a clear bias towards the selection of glue variables over nonglue variables.

Figure 2 compares two ratios, $R_{G}=\frac{\#gd}{GF}$ and $R_{NG}=\frac{\#ngd}{NGF}$ in log scale. $R_{G}$ (resp. $R_{NG}$) measures the number of glue decisions (resp. nonglue decisions) w.r.t. glue (resp. nonglue) variable pool size for the 750 instances. It clearly shows that glue decisions relative to glue variables pool fractions are higher than nonglue decisions relative to the nonglue variables pool fractions for most of the instances.

To summarize, decisions with glue variables are categorically more conflict efficient than decisions with nonglue variables. As a result, CDCL branching heuristics exhibits clear bias towards glue variables over nonglue variables.

4 Activity Score Bumping for Glue Variables

From the above analysis, it is clear that decisions with glue variables are more conflict efficient than with nonglue variables. An interesting question is how we can exploit this empirical characteristic for more efficient CDCL SAT solving.

In this section, we present a score bumping method, called Glue Bump (GB), for bumping the activity scores of glue variables on top of the standard activity-based CDCL branching heuristics. The design of this combination is to give more preference towards the selection of recently active high centrality glue variables.

The GB Method

The GB method modifies a CDCL SAT solver $M$ by adding two procedures to it, named Increase Glue Level and Bump Glue Variable, which are called at different states of the search. We denote by $M^{gb}$ the GB extension of the solver $M$.

Increase Glue Level: Whenever $M^{gb}$ learns a new glue clause $g$, before making an assignment with the first UIP variable that appears in $g$, it invokes Algorithm 1. For each variable $v_{g}$ in $g$, its glue level of $v_{g}$ is increased by 1 (Line 3).

Clause $g$ is the latest learned clause and all the variables in $g$ are assigned in the current search state. A variable in $g$ becomes a candidate branching variable again if it becomes unassigned by backtracking. $M^{gb}$ delays the bumping of $v_{g}$ until it is unassigned by backtracking. The extended solver invokes the bumping routine for $v_{g}$, right after $v_{g}$ becomes unassigned by backtracking.

Bump Glue Variable: Algorithm 2 bumps a glue variable $v_{g}$, which has just been unassigned by backtracking. This is done by adding a *bumping factor * to its activity score (Lines 2, 3). The bumping factor takes two intuitions into considerations:

(a) At a given state of the search, the glue centrality of a glue variable measures the glue level of that variable relative to the glue levels of all the glue variables. Given a glue clause $g$, let $\{v_{g},v_{g}^{\prime}\}\in g$ with $gc(v_{g})>gc(v_{g}^{\prime})$. Compared to $v_{g}^{\prime}$, $v_{g}$ can potentially affect more blocks of variables and has bigger potential to create conflicts. (b) Activity score of a variable measures the extent of involvement of that variable in recent conflicts and indicates its chance to be involved again in a conflict in the near future.

Heuristically, a good bumping factor combines both of the activity score and glue centrality of the glue variables. Hence, $M^{gb}$ computes the bumping factor for a glue variable $v_{g}$ by multiplying its current activity score $activity(v_{g})$ and its glue centrality $gc({v_{g}})$.

5 Experiments

We conduct our experiments using MapleLCMDistgb and MapleLCMDistChronoBTgb, which implement the GB method on top of the solvers MapleLCMDist and MapleLCMDistChronoBT, respectively. The branching heuristics in these baseline solvers do not distinguish between glue and nonglue variables. We run all the 750 main track instances from SAT-2017 and 2018 on the same machine as mentioned earlier with 5000 seconds timeout limit for each instance.

MapleLCMDist vs. MapleLCMDistgb: Columns (A) and (B) of Table 2 compare the performance of MapleLCMDist and MapleLCMDistgb. Our GB extension achieves a total gain of 5 instances over its baseline, of which 3 are satisfiable and 2 are unsatisfiable. Overall, MapleLCMDistgb has a smaller PAR-2 score compared to its baseline, which reflects the overall stronger performance of MapleLCMDistgb over its baseline.

MapleLCMDistChronoBT vs MapleLCMDistChronoBTgb: Both solvers solve an equal numbers of instances (Columns C and D, Table 2). However, MapleLCMDistChronoBTgb solves some of the instances faster than MapleLCMDistChronoBT, which is reflected in its overall lower PAR-2 score.

Solved Time Comparison: Figure 3 compares the performance of MapleLCMDistgb (blue line) and MapleLCMDistChronoBTgb (red line) against their baselines, MapleLCMDist and MapleLCMDistChronoBT, respectively, This figure plots the difference in number of instances solved as a function of time. At most points in time, the extended solvers improve on the number of solved problems. This is especially pronounced at first time limits (blue line) for MapleLCMDistgb and at intermediate time limits (red line) for MapleLCMDistChronoBTgb.

Overall, the GB method improves the performance of both baseline solvers, which is reflected in the lower PAR-2 scores of the extended solvers.

6 Discussion

In this section we analyze our experimental results reported in the previous section to reveal some insights on the inner workings of the GB method. We limit our discussion with MLDgb for the space restraint.

Propagation Rate, Global Learning Rate (GLR) and average LBD: Table 3 shows the Propagation Rate, Global Learning Rate and average LBD score of the learned clauses for MapleLCMDist and MapleLCMDistgb for the 750 instances.

MapleLCMDistgb has higher PR (Column A), equal GLR (Column B) and lower average LBD (Column C). Compared to its baseline the bumping of glue variables helps MapleLCMDistgb achieve better inference rate, to generate conflicts at an equal rate from which it learns slightly higher quality clauses on average. In [9], the authors showed that better branching heuristics increase GLR and lower the average LBD scores of the learned clauses compared to the less efficient ones. Thus our result is largely consistent with the result of [9].

Impact of GB on Glue Decisions: The GB method is designed to prioritize the selection of glue variables. Here, we take a closer look at the impact of this strategy on glue decisions for MapleLCMDistgb and its baseline. As shown in Table 4, the GB method in MapleLCMDistgb indeed increases the average number of glue decisions (Column A) to 28.0 millions (47.85% of total decisions in MapleLCMDistgb) from 26.8 millions (47.60% of total decisions in MapleLCMDist), which is the average number of glue decisions taken by MapleLCMDist.

Though GB method increases total number of propagations (not shown in Table 4) on average, the increased average number of glue decisions lowers the average PR (Column B). The increased glue decisions also generates conflicts at the same rate (Column C) from which slightly better quality clauses are learned (Column D), on average.

7 Related Work

In Glucose [1], the authors explicitly increased the activity scores of variables of the learned clause that were propagated by a glue clause. In their work, the bumping was based on VSIDS score bumping scheme. Here, we increase the activity scores of variables that appear in glue clauses based on glue centrality, which is a structure aware measure, to improve sate-of-the-art CDCL SAT solvers. In [6], the authors studied the behavior of the CDCL SAT solver Glucose w.r.t. eigencentrality, a precomputed static measure of the variables in industrial SAT instances. It shows that the branched and propagated variables in Glucose has high eigencentrality and the learned clauses contains high eigencentral variables than conflict clauses. In contrast, we dynamically characterize glue and nonglue variables within the course of a search and show that decisions with glue variables are categorically more inference and conflict efficient than decisions with nonglue variables. In [8], the authors have shown that the VSIDS heuristic disproportionately branches more often on those variables which are the bridges between communities. Here, we show that CDCL heuristics branches disproportionately more often on glue variables w.r.t. their relatively smaller pool size. In [5], the authors exploit the betweeness centrality of the variables in industrial SAT formulas to design new heuristics. In their work, betweenness centralities of the variables in a given instance are precomputed before the search begins by using an external python package. In contrast, we compute the glue centrality of the variables during the search without using any external tool.

8 Future Work

In this work, we show that variables appearing in glue clauses are more inference and conflict efficient than other variables. We also show that prioritizing glue variable selection improves the performance of CDCL SAT solvers MapleLCMDist and MapleLCMDistChronoBT. In the future, we plan to pursue the following research questions: (I) are there any correspondence between glue centrality and other centrality measures, such as, eigencentrality, betweenness centrality? (II) In our experiment, some of the benchmark instances have high fraction of glue variables, while for the others only a small fraction of the variables are glue variables. We plan to study this partition of benchmarks to find out their structural differences.