Constraint Sequence Solving for VLSI Design

Ateet BhallaTechnocrats Institute of Technology, Bhopal, India

{bhalla.ateet}@gmail.com

Abstract

For VLSI design which have large collection of objects tobe constrained, clear sequence of execution of constraints isimportant using constraint-satisfaction method for properexecution to avoid constraint loop at algorithmic level. Theobjective of this paper is relaxation based constraint se-quence solving technique applied to the backtrack step ofbacktrack search solver, with the goal of increasing the abil-ity of the solver to search different parts of the search space.The experimental results are promising, and motivate the in-tegration of relaxation based constraint sequence solving instate-of-the-art solvers.

1. Introduction

Propositional Satisfiability is a well-known NP-completeproblem, with theoretical and practical significance, andwith extensive applications in many fields of ComputerScience and Engineering, including Electronic Design Au-tomation.

Current state-of-the-art SAT solvers incorporate sophis-ticated pruning techniques as well as new strategies on howto organize the search. Effective search pruning techniquesare based [2, 3, 4], among others, on no-good learning anddependency-directed backtracking [15], whereas recent ef-fective strategies introduce variations on the organizationof backtrack search. Examples of such strategies are searchrestarts [5].

SAT algorithms can be characterized as being eithercomplete or incomplete. Complete algorithms can establishunsatisfiability if given enough CPU time; incomplete al-gorithms cannot. Examples of complete and incomplete al-gorithms are backtrack search and local search algorithms,respectively. In a search context, complete algorithms areoften referred to as systematic, whereas incomplete algo-rithms are referred to as non-systematic.

But because of their inherent randomness, the behaviorof stochastic local search algorithms is generally difficult toanalyze theoretically, and even in the cases where theoreti-

cal results do exist, their practical applicability is often lim-ited. However, from practical real-world applications fromthe EDA domain, local search algorithms are not suited be-cause these problems represent highly constrained spaces.Moreover, and from a practical perspective, the most effec-tive algorithms are complete, and so able to prove what lo-cal search is not capable of, i.e. unsatisfiability. Indeed, thisis often the objective in a large number of significant real-world applications.

Nevertheless, it is also widely accepted that local searchhas some advantages with respect to backtrack search. Al-though it is debatable which are the real advantages of lo-cal search (e.g. see [9]), one of them seems to be the useof search restarts. Search restarts avoid the search to getstuck in a locally optimal partial solution. The advantageof search restarts has motivated the study of approaches forrelaxing backtracking conditions (while still ensuring com-pleteness). The key idea is to unrestrictedly choose the pointto backtrack to, in order to avoid thrashing during back-track search. Moreover, one can think of combining dif-ferent forms of relaxing the identification of the backtrackpoint.

The remainder of this paper is organized as follows. Thenext section introduces the definitions that will be usedthroughout the paper. Then we present a brief survey ofbacktrack search SAT algorithms. Section 4 describes relax-ation based constraint sequence solving procedure and com-pleteness techniques. Finally, we present experimental re-sults and conclude with directions for future research work.

2. Definitions

This section introduces the notational framework usedthroughout the paper. Propositional variables are denotedx1, . . . , xn, and can be assigned truth values 0 (or F ) or 1(or T ). The truth value assigned to a variable x is denotedby ν(x). (When clear from context we use x = νx, whereνx ∈ {0, 1}). A literal l is either a variable x or its nega-tion ¬x. A clause ω is a disjunction of literals and a CNFformula ϕ is a conjunction of clauses. A clause is said to besatisfied if at least one of its literals assumes value 1, un-satisfied if all of its literals assume value 0, unit if all but

978-1-4244-7808-8/10/$26.00 ©2010 IEEE 182 2nd Asia Symposium on Quality Electronic Design

one literal assume value 0, and unresolved otherwise. Liter-als with no assigned truth value are said to be free literals.A formula is said to be satisfied if all its clauses are satis-fied, and is unsatisfied if at least one clause is unsatisfied.A truth assignment for a formula is a set of assigned vari-ables and their corresponding truth values. The SAT prob-lem consists of deciding whether there exists a truth assign-ment to the variables such that the formula becomes satis-fied.

3. Backtrack Search SAT Algorithms

Many SAT solving procedures have been proposed tosolve SAT problems, for instance, from the areas of formalverification. Most practical SAT solvers use the splittingtechnique and combine it with backtracking. Backtrackingsearches the search space in a depth-first order and thusavoids excessive memory requirements. Among the differ-ent algorithms proposed, backtrack search is the most ro-bust approach for SAT solving. Over the years a large num-ber of algorithms have been proposed for SAT, the vast ma-jority of backtrack search SAT algorithms build upon theoriginal backtrack search algorithm of Davis, Putnam, Lo-gemann and Loveland [10, 11] to recent backtrack searchalgorithms [6, 7, 8].

The backtrack search algorithm is implemented by asearch process that implicitly enumerates the space of 2n

possible binary assignments to the n problem variables.Each different truth assignment defines a search path withinthe search space. A decision level is associated with eachvariable selection and assignment. The first variable selec-tion corresponds to decision level 1, and the decision level isincremented by 1 for each new decision assignment 1. In ad-dition, and for each decision level, the unit clause rule [10]is applied. If a clause is unit, then the sole free literal mustbe assigned value 1 for the formula to be satisfied. In thiscase, the value of the literal and of the associated variableare said to be implied. The iterated application of the unitclause rule is often referred to as Boolean Constraint Prop-agation (BCP).

In chronological backtracking, the search algo-rithm keeps track of which decision assignments havebeen toggled. Given an unsatisfied clause (i.e. a con-flict or a dead end) at decision level d, the algorithm checkswhether at the current decision level the corresponding de-cision variable x has already been toggled. If not, thealgorithms erases the variable assignments which are im-plied by the assignment on x, including the assignmenton x, assigns the opposite value to x, and marks deci-sion variable x as toggled. In contrast, if the value of x

1 Observe that all the assignments made before the first decision assign-ment correspond to decision level 0.

has already been toggled, the search backtracks to deci-sion level d− 1.

Recent state-of-the-art SAT solvers utilize differ-ent forms of non-chronological backtracking [6, 7, 8], inwhich each identified conflict is analyzed, its causes iden-tified, and a new clause created to explain and pre-vent the identified conflicting conditions. Created clausesare then used to compute the backtrack point as themost recent decision assignment from all the decision as-signments represented in the recorded clause. More-over, some of the (larger) recorded clauses are eventuallydeleted. Clauses can be deleted opportunistically when-ever they are no longer relevant for the current searchpath [6].

4. Relaxation Based Constraint Solving

Improvements to the basic backtracking approach can bedone before performing the search to bound the size of thesearch space, and used dynamically during the search to de-cide which parts of the search space will not be visited.

Decide the backtrack point. The naive backtracking al-gorithms always steps one variable back. This is mostly notadvantageous because the reason for the failure might havebeen occurred much earlier in the search tree. By analyzingthe reasons for the dead-end, irrelevant backtrack points canoften be avoided so that the algorithm goes back directly tothe cause of failure instead of just to the immediately pre-ceding variable in the ordering in order to avoid thrashing,that is exploring useless portions of the search space corre-sponding to very similar conflicting sets of assignments dur-ing backtrack search. This is known as dependency-directedbacktracking [15].

While backjumping schemes is more powerful than sim-ple backtracking, they still cannot avoid all thrashing. Thebackjumping method does not record the information aboutthe conflict clause, and can lead to search paths being re-visited. The idea of dependency-directed backtracking wasintroduced to address this issue. This method records in-formation as an extra clause termed as no-good, each timea conflict is diagnosed. This learned clause prevents thesearch paths from being revisited. The only drawback tothis method [15] is every time the procedure backtracks anew no-good is learned. In turn, this makes the space com-plexity of the dependency-directed backtracking methodcomparable to its time complexity, and since the constraintsatisfaction problem is NP-hard, both complexities maybe exponential. Unfortunately, neither naive backtrackingnor dependency-directed backtracking is very effective toprune the search space because backtracking remains sim-ply chronological in nature.

Now the problem is how to bound the space complexity,so that only no-goods up to a certain size k are kept.

As an alternative to computationally expensive solutionmethod of [15], the proposed relaxation algorithm whichconsists of selecting the backtrack point in the constrainttree as a function of variables in the most recently recordedclause, is a technique of solving constraint loop, by avoid-ing the search to get stuck in a locally optimal partial so-lution by relaxing the backtracking conditions and reduc-ing constraint loop to simpler constraints. This type of re-laxation based constraint sequence solving which uses aniterative procedure and a simple heuristic for variable se-lection for computing global implications to perform jus-tification, propagation and implication, where each vertexis associated with a literal corresponding to an assignmentalong with its decision level in an implication graph. Thisrelaxation based constraint sequence solving algorithm inVLSI design environment represents many relevant piecesof circuit information coded as constraints and the type ofprogramming involves constraints, variables, algebraic ex-pressions that are attached to a circuit design at algorithmiclevel. In VLSI design, this type of declarative programmingappears as constraints in the form of schematics consist-ing of propositonal variables with boolean logic truth val-ues that are attached to a design. The sequencing of theseconstraints is dependent on the structure of circuit. A SATformula is a powerful expression for representing the rela-tions inherent in a circuit by creating the CNF formula forthe circuit. A direct mapping can be established from thecircuit to a SAT CNF formula. This combines the advan-tages of structure based and SAT based techniques and isimportant in VLSI design systems, which have large collec-tions of objects to be constrained.

Different relaxation based constraint sequencing tech-niques can be envisioned. In all cases the backtrack pointis computed as the variable with the largest heuristic met-ric termed as heuristic based relaxation(HBSAT).

In relaxation algorithm the backtrack point is com-puted from heuristic information, obtained from the currentand past conflicts. A crucial factor influencing the perfor-mance of a Davis-Putnam-Logemann-Loveland (DPLL) al-gorithm [10, 11] based SAT solver is its decision heuristic.This heuristic decides which variable to choose at each de-cision point during the search and what value to assign itfirst. In recent years, the field has been a witness to a break-through in the design of decision heuristics that areempirically successful on real-world industrial SAT in-stances.

Next, we describe different constraint sequence solvingtechniques that can be envisioned.

With first technique of relaxation based constraint se-quence (RelCST-1), after a conflict (i.e. an unsatisfiedclause) is identified, a conflict clause is created. The con-flict clause is then used for heuristically deciding which de-cision assignment is to be toggled. Observe that when a

conflict clause is created all the literals in the clause are as-signed value 0. Under Non-Chronological Backtrackingthis fact motivates the search to backtrack to the most re-cent decision level with implications on the conflictclause.

Under the (RelCST-1) relaxation approach, the search isallowed to backtrack to any decision level with implicationson the literals of the conflict clause. The backtrack point(i.e. decision level) is computed by selecting the decisionlevel with the largest number of occurrences (assigned orimplied literals) in the newly recorded clause. This contrastswith the usual non-chronological backtracking approach, inwhich the most recent decision variable with implicationson the conflict is selected as the backtrack point.

Example 4.1 Suppose that relaxation based constraintsequence solving is to be applied after recording clauseω = (x1 ∨ x3 ∨ ¬x5 ∨ ¬x9 ∨ x12). Also, suppose thateach literal in ω has been assigned at a given decision level:ω = (x1@10∨x3@7∨¬x5@8∨¬x9@7∨x12@2). Clearly,the decision level with the largest number of occurrences(in this case 2 occurrences) is decision level 7. Hence, re-laxation makes the search backtrack to level 7.

With second technique of relaxation based constraint se-quence (RelCST-2), we have a counter for each literal. Eachcounter is initialized with the number of occurrences ofthe literal in the formula. Moreover, each counter is incre-mented when a new conflict clause containing the literal isadded to the clause database. In addition, after every k de-cisions, the metric values are divided by a constant factor of2, to give preference to variables occurring in the latest con-flict clauses. Whenever a conflict occurs, the literal in thejust recorded clause with the highest metric is used to se-lect the backtrack point.

Example 4.2 Suppose that the relaxation based con-straint sequence solving is to be applied after recordingclause ω = (x1@10∨ x3@7∨¬x5@8∨¬x9@7∨ x12@2).In addition, suppose that the HBSAT metric for a given con-straint x is given by HBSAT(x) and that HBSAT(x1) = 45,HBSAT(x3) = 5, HBSAT(x5) = 94, HBSAT(x9) = 32and HBSAT(x12) = 41. The literal in the just recordedclause with the highest metric is x5. Hence, the HBSAT re-laxation makes the search backtrack to level 8, i.e., the levelwhere x5 was assigned.

With third technique of relaxation based constraint se-quence (RelCST-3), we increment the metrics of the liter-als in all clauses that are directly involved in producing theconflict. The metrics are updated during the process of con-flicts analysis, which can find all clauses involved in pro-ducing the conflict by traversing an implication graph datastructure. This process finishes with the creation of the con-flict clause. Literal in the conflict clause with the highestmetric is used to select the backtrack point.

Example 4.3 Consider again the clause given in Example

4.2 with the following constraint sequence: ω = (x1@10 ∨x3@7 ∨ ¬x5@8 ∨ ¬x9@7 ∨ x12@2). Also, suppose thatthe values given for the HBSAT metric are given by func-tion hbsat and that HBSAT(x1) = 31, HBSAT(x3) = 38,HBSAT(x5) = 2, HBSAT(x9) = 15 and HBSAT(x12) =53. The literal in the just recorded clause with the highestmetric is x12. Hence, HBSAT relaxation makes the searchbacktrack to level 2, i.e. the level where x12 has been as-signed.

Simply replacing deterministic backtracking with relax-ation based constraint solving technique has two majordrawbacks: (1) the resulting algorithm is no longer com-plete and (2) an algorithm applying relaxation constraint se-quence technique for every backtrack step becomes very un-stable.

In order to eliminate these drawbacks, we introduce theconcept of relaxation algorithms. Each backtrack step is ei-ther a complete form of backtracking (i.e. chronological ornon-chronological backtracking) or an incomplete form ofbacktracking (i.e. HBSAT). Clearly, a relaxation algorithmapplying relaxation technique after every k steps (with k >1) and non-chronological backtracking every other steps ismore stable than a relaxation algorithm for every backtrackstep. An algorithm applying relaxation technique for ev-ery backtrack step becomes very unstable, frequent appli-cations cause the algorithm to wander without focusing inregions of the search space that need a more thorough ex-ploration. When applied infrequently, relaxation techniqueallows finding a solution or proving unsatisfiability using asignificantly lower number of decisions. Large instances dobenefit from relaxation techniques, as these techniques helpget out of dead-ends in the search tree. This is why theyshould be applied infrequently.

More formally, relaxation based constraint sequencesolving allows the application of a sequence of back-track steps {BSt1,BSt2,BSt3, . . .} such that each back-track step BSti can either be a Chronological (CB), aNon-Chronological (NCB) or an Incomplete Form of Back-tracking (IFB).

Completeness techniques for constraint sequence solv-ing using relaxation algorithm can be organized in twoclasses:

• Marking recorded clauses as non-deletable. This solu-tion may yield an exponential growth in the number ofrecorded clauses 2.

• Increasing a given constraint (e.g. the number of non-deletable recorded clauses) in between applications ofdifferent constraint sequence solving schemes. Thissolution can be used to guarantee a polynomial growthof the number of recorded clauses.

2 In practice an exponential growth in the number of recorded clauseshardly ever arises

5. Experimental Results

In recent years backtrack search SAT solvers have beenthe subject of dramatic improvements. These improvementsallowed SAT solvers to successfully replace binary deci-sion diagram (BDDs) in many areas of formal verification,and also motivated the development of many new challeng-ing problem instances, many of which too hard for the cur-rent generation of SAT solvers. As a result, further improve-ments to SAT technology are expected to have key conse-quences in formal verification.

This section presents the experimental analysis ofthe stability and performance of the relaxation algo-rithms developed on a wide variety of benchmarksranging from the DIMACS suite of benchmarks (TheDIMACS benchmarks are available from via anony-mous FTP from dimacs.rutgers.edu. in the directorypub/challenge/sat/benchmarks), SATLIB suite of bench-marks (benchmark instances can be found on the website http://www.cs.ubc.ca/ hoos/SATLIB/benchm.html), topractical real-world instances coming from industrial appli-cations. In computer-aided design, tools for synthesis, opti-mization, verification, and test pattern generation use vari-ants of SAT solvers as core algorithms. Spurred by therecent advancements in SAT solver technology, SAT al-gorithms have been successfully applied to problemsfrom a wide variety of EDA applications [1]. In the pro-cess of designing and manufacturing of VLSI hardware,various methods for verification are used, basically di-vided into simulations and formal verification. Verifica-tion has provided the richest application domain for use ofSAT in EDA. Here we give some examples of SAT applica-tions in the EDA domain.

We focus on instances of SAT coming from the hardwareverification domain, namely superscalar processor verifica-tion [12]. These instances can be either satisfiable or unsat-isfiable and are in general extremely hard for state-of-the-artSAT solvers. Velev et al. investigated the use of SAT proce-dures in microprocessor test and verification [12]. The mi-croprocessor verification task is expressed in the logic ofequality with uninterpreted functions (EUF). In this logicthe formulas are formed using Boolean connectives forcomparing equality of the terms describing results producedby modeling hardware designs and then proving validity ofthis formula by adopting Boolean methods through the useof satisfiability procedures for propositional logic.

We also focus on another application in the verifica-tion domain Bounded Model Checking (BMC), proposedby Biere et al. in 1999 [13]. BMC formulates reachabilitychecks as a series of satisfiability problems for paths of in-creasing bounded k) length. In practice, to see if a path oflength n connecting initial and failure states exists, the tran-sition relation of the system is unrolled n times, and the

SAT solver is run on the generated problem. The motiva-tion of bounded model checking was to leverage the suc-cess of SAT in solving Boolean formulas for model check-ing. Normally verification with BMC is based on a gradualprocess, where (k) is increased until either a bug is found orthe problem becomes intractable. The BMC problem can beefficiently reduced to a propositional satisfiability problem,and can therefore be solved by SAT methods. We also fo-cus on bounded model checking (bmc-ibm) instance fromreal industrial hardware design from IBM.

Application specific improvements is also presented withdirect application of SAT solvers to various EDA compu-tational tasks have been shown with their ability to han-dle non-CNF constraints. We also focus on instances dataencryption standard (DES) based on encoding of crypto-graphic algorithms as SAT problem and bejing benchmarkinstances from SAT competition. SAT can also be used toverify the equivalence of two combinational circuits withequiv-checking benchmark instances.

5.1. Experimental Results: Stability

We compare relaxation based constraint sequencesolving algorithm with non-chronological backtrack-ing and other forms of backtracking relaxations, namelynon-chronological backtracking combined with searchrestarts [5], one of the most effective backtracking re-laxation schemes known to date. The search is repeat-edly restarted whenever a cutoff value is reached. Thealgorithm proposed is not complete, since the restart cut-off point is kept constant. Search restarts are now partof the most competitive backtrack search SAT algo-rithms [7, 8] and our goal here has been to demonstratethat relaxation based constraint sequence solving tech-niques is a more competitive form of backtracking relax-ation. Experimental evaluation of the relaxation algorithmshas been done using the JQUEST SAT framework [14],a Java framework for prototyping SAT algorithms. It of-fers a significantly faster development time for testing newideas in SAT algorithms. The CPU time limit for each in-stance was set to 104 sec. All the experiments were runon the same P4/1.7GHz/1GByte of RAM/Linux ma-chine. Different SAT algorithm prototypes have been im-plemented and compared. The algorithms differ onlyin the relaxation strategy applied. In choosing a deci-sion or backtrack variable, a slight randomization isused to select among the variables with the best met-rics provided by the different heuristics. Combining thevalues of the metrics with a certain degree of random-ization is known to produce good results. The main con-clusions from the data provided is that heuristics-relatedparameters improve the performance on most of the bench-marks.

The algorithms have been applied to 11 different classesof problem instances containing 278 problem instances intotal as shown in Table 1. In NCB, a non-chronologicalbacktrack step is performed every step. The sequence ofbacktracking steps that has been applied in the other algo-rithms is defined as follows: an incomplete form of back-tracking step (HBSAT or restarts) is performed after every104 + i×103 backtracks, where i is incremented every timean IFB step is performed. The increase of constraint i andthe fact that conflict derived clauses are marked undeletableguarantee the completeness of the algorithms.

Table 1 shows the results obtained for each class of in-stances. #I denotes the number of problem instances, Decdenotes the average number of decision nodes per instance,Time denotes the average CPU time per instance and X de-notes the number of aborted instances. In addition, each col-umn indicates a different form of relaxation techniques:

• NCB indicates non-chronological backtracking is ap-plied in every backtrack step.

• RST indicates that search restarts are applied after104 + i × 103 backtracks, where i is incremented ev-ery time a search restart is taken.

• RelCST(1) indicates relaxation algorithm is applied af-ter 104 + i × 103 backtracks, where i is incrementedevery time a HBSAT step is taken.

• RelCST(2) indicates relaxation algorithm is applied af-ter 104 + i × 103 backtracks, where i is incrementedevery time a HBSAT step is taken.

• RelCST(3) indicates relaxation algorithm is applied af-ter 104 + i × 103 backtracks, where i is incrementedevery time a HBSAT step is taken.

From the results shown in Table 1 several observationsand comments can be made. In a set of 278 instances,the best relaxation algorithm RelCST(3) shows an averagespeed-up of about 3.5× against the search restarts algo-rithm. Relaxation based constraint sequence solving algo-rithm abort less instances. An instance is aborted wheneverthe memory or CPU time constraint is reached. In these ex-periments all instance abortions have been caused by mem-ory exhaustion, which shows that less clauses are storedusing RelCST as compared to search restarts. A possibleexplanation for this is that our heuristics are more likelyto reuse information provided by earlier conflicts than thesearch restarts algorithm, which is more prone to encounternew conflict clauses after each restart. Equivalently, onecan say that RelCST favors a more local search rather thansearch restarts.

5.2. Experimental Results: Performance

To show that the performance of the heuristics improvewith the hardness of the problem instances, we manually se-

lected a set of 16 individual harder-to-solve instances, forwhich the results are given in Table 2. The results in Table 2show that for the set of harder-to-solve instances the benefitsof relaxation techniques are more visible. The three RelCSTalgorithms perform better than the search restarts algorithmand non-chronological backtracking which aborted 3 of theinstances (marked with ∗).

The relaxation technique RelCST(3) was again the bestof the three relaxation algorithms. Its average speed-upagainst the search restarts algorithm has been computed asgreater than 9.63×.

As can be concluded from the experimental results, re-laxation algorithm (RelCST) can yield significant savingsin CPU time, and also allow for a smaller number of in-stances to be aborted. This is true for several of the classesof problem instances analyzed.

6. Conclusions and Future Work

This paper proposes the utilization of relaxation basedconstraint sequence solving. The experimental results illus-trate the practicality of the proposed technique in State-of-the-art SAT solvers. In fact, hundreds of problem instanceshave been analyzed, where relaxation algorithm have beencompared to a state-of-the-art SAT solver algorithm. Theonly difference between the new relaxation technique andthe reference SAT solver algorithm is the backtracking step:the new algorithms apply relaxation steps instead of searchrestarts, the best form of incomplete backtracking known todate.

The main contributions of this paper can be summarizedas follows:

1. A new constraint sequence solving procedure is pro-posed, that heuristically selects the point to backtrackto.

2. For the proposed algorithm different approaches forensuring completeness are established.

3. Experimental results indicate that significant savingsin search effort can be obtained for different organiza-tions of the proposed relaxation algorithm.

The constraint sequence solving procedure developed inthis work is now ready to be incorporated in state-of-the-artsolver. For future work, a more comprehensive experimen-tal evaluation is required for combining different forms ofdecision heuristics and relaxation algorithms, thus motivat-ing the utilization of multiple search strategies in backtracksearch SAT solvers.

References

[1] J. P. Marques-Silva and K. A. Sakallah. Boolean Satisfiabil-ity in Electronic Design Automation. In Proceedings of theDesign Automation Conference, pages 675-680, June 2000.

[2] D. Babic, J. D. Bingham, and A. J. Hu. Efficient SAT Solv-ing: Beyond Supercubes. In Proceedings of the Design Au-tomation Conference, pages 744–749, June 2005.

[3] D. Babic, J. D. Bingham, and A. J. Hu. B-Cubing: New Pos-sibilities for Efficient SAT-Solving. IEEE Transactions onComputers, 55(11):1315–1324, November 2006.

[4] F. Hutter, D. Babic, H. Hoos, and A. J. Hu. Boosting Ver-ification by Automatic Tuning of Decision Procedures. InProceedings of Formal Methods in Computer-Aided Design,pages 27–34, 2007.

[5] C. P. Gomes, B. Selman, and H. Kautz. Boosting combinato-rial search through randomization. In Proceedings of the Na-tional Conference on Artificial Intelligence, pages 431–437,July 1998.

[6] J. P. Marques-Silva and K. A. Sakallah. GRASP-A searchalgorithm for propositional satisfiability. IEEE Transactionson Computers, 48(5):506–521, May 1999.

[7] M. Moskewicz, C. Madigan, Y. Zhao, L. Zhang, and S. Ma-lik. Chaff: Engineering an efficient SAT solver. In Proceed-ings of the Design Automation Conference, pages 530–535,June 2001.

[8] E. Goldberg and Y. Novikov. BerkMin: a fast and robust sat-solver. In Proceedings of the Design and Test in Europe Con-ference, pages 142–149, March 2002.

[9] E. C. Freuder, R. Dechter, M. L. Ginsberg, B. Selman, andE. Tsang. Systematic Versus Stochastic Constraint Satisfac-tion. In Proceedings of the International Joint Conferenceon Artificial Intelligence, pages 2027–2032, 1995.

[10] M. Davis and H. Putnam. A computing procedure for quan-tification theory. Journal of the Association for ComputingMachinery, 7:201–215, July 1960.

[11] M. Davis, G. Logemann, and D. Loveland. A machine pro-gram for theorem-proving. Communications of the Associa-tion for Computing Machinery, 5:394–397, July 1962.

[12] M. Velev and R. E. Bryant. Superscalar Processor Verifica-tion Using Efficient Reductions from the Logic of Equalitywith Uninterpreted Functions to Propositional Logic. In Pro-ceedings of Correct Hardware Design and Verification Meth-ods, pages 37–53, 1999.

[13] A. Biere, A. Cimatti, E. Clarke and Y. Zhu Symbolic ModelChecking without BDDs. In Proceedings of Tools and Algo-rithms for the Construction and Analysis of Systems, pages193–207, 1999.

[14] I. Lynce and J. P. Marques-Silva. Efficient data structures forbacktrack search SAT solvers. Annals of Mathematics andArtificial Intelligence, 43(1):137–152, January 2005.

[15] R. M. Stallman and G. J. Sussman. Forward reasoning anddependency-directed backtracking in a system for computer-aided circuit analysis. Artificial Intelligence, 9:135–196, Oc-tober 1977.

Benchmarks #I RelCST(1) RelCST(2) RelCST(3) RSTDec Time X Dec Time X Dec Time X Dec Time X

BMC-barrel 8 1307492 4070.22 0 1013787 1819.11 0 584680 735.61 0 1031297 2397.81 0

BMC-queueinvar 10 84784 33.02 0 85666 42.04 0 69758 25.86 0 66713 20.93 0

BMC-longmult 16 1112467 5868.87 3 937649 3088.83 3 946813 4276.77 3 1177463 7873.19 5

sss-sat-1.0 100 3470750 3018.83 0 3005868 1785.38 0 1486274 877.58 0 3142078 2425.27 0

sss-1.0 48 939535 658.87 0 681025 199.68 0 467650 93.97 0 736851 408.56 0

sss-1.0a 9 191838 230.41 0 176227 108.77 0 98217 37.51 0 198363 459.68 0

fvp-unsat.1.0 4 191300 180.93 1 196671 217.28 1 102657 38.94 1 167714 109.31 1

beijing 16 522884 5055.56 2 509764 4063.42 2 517462 4906.94 2 523849 5284.38 2

equiv-checking 25 2317494 2035.26 2 2355508 2282.49 2 913835 1101.26 2 2853280 3467.24 2

parity16 10 74641 41.12 0 72607 27.81 0 56619 18.11 0 111228 79.95 0

des-encryption 32 533520 3801.09 2 512640 3194.06 2 480812 2885.39 2 578128 5005.26 2

Table 1. Performance of different algorithms.

Benchmarks Instance RelCST(1) RelCST(2) RelCST(3) RST NCBDec Time Dec Time Dec Time Dec Time Dec Time

BMC barrel9 869896 3332.68 780650 2542.17 238566 391.11 707033 1903.58 790029 2660.51

BMC longmult10 229373 1720.57 220432 1234.40 188654 573.41 ∗ ∗ ∗ ∗BMC longmult15 284658 2500.61 175422 672.68 219087 1487.77 ∗ ∗ ∗ ∗bmc ibm-13 71365 398.69 90360 725.54 54651 69.81 66632 191.45 78713 591.70

sss-sat-1.0 2dlx ...bug056 56197 34.88 52240 31.86 24565 19.48 60345 48.23 63303 56.32

sss.1.0a dlx2 ...bug54 29744 36.71 24466 33.21 2304 11.60 36596 58.94 35018 53.01

sss.1.0 dlx2 cl 17144 9.65 12882 4.92 13206 6.95 33244 14.13 36781 15.98

fvp-unsat.1.0 2dlx ca ...bp f 36156 30.36 32294 19.24 31181 15.42 42027 40.47 47982 83.67

fvp-unsat.2.0 4pipe 1 241314 392.26 361487 934.43 83742 50.29 ∗ ∗ ∗ ∗equiv-checking c7552 198240 95.92 243101 145.48 151021 75.93 313592 293.61 318831 461.34

equiv-checking c7552-s 295689 158.52 400875 347.84 175070 58.91 411626 594.24 444888 867.96

equiv-checking c3540 bug 2211 1.34 2560 2.69 557 0.38 3378 4.95 8472 15.24

des-encryption cnf-r3-b1-k1.1 9943 6.25 10937 9.31 4716 1.11 13068 18.75 13960 21.65

des-encryption cnf-r3-b1-k1.2 2275 1.18 5566 2.82 1220 0.76 7792 3.36 8042 4.76

parity16 par16-1-c 8866 3.65 8019 2.70 7273 1.31 11143 18.81 21773 25.74

parity16 par16-4 1964 2.41 1117 1.65 887 0.41 3378 3.55 3386 4.48

Table 2. Performance of different algorithms on individual instances.