Robust Boolean Reasoning for Equivalence Checking and Functional Property Verification

Transcription

1 IEEE TRANSACTIONS ON COMPUTER-AIDED DESIGN OF INTEGRATED CIRCUITS AND SYSTEMS, VOL., NO. Y, MONTH Roust Boolen Resoning for Equivlene Cheking nd Funtionl Property Verifition Andres Kuehlmnn, Senior Memer, IEEE, Viresh Pruthi, Florin Krohm, nd Mly K. Gni, Memer, IEEE Astrt Mny tsks in CAD, suh s equivlene heking, property heking, logi synthesis, nd flse pths nlysis require effiient Boolen resoning for prolems derived from iruits. Trditionlly, nonil representtions, e.g., BDDs, or struturl SAT methods, re used to solve different prolem instnes. Eh of these tehniques offer speifi strengths tht mke them effiient for prtiulr prolem strutures. However, neither struturl tehniques sed on SAT, nor funtionl methods using BDDs offer n overll roust resoning mehnism tht works relily for rod set of pplitions. In this pper we present omintion of tehniques for Boolen resoning sed on BDDs, struturl trnsformtions, SAT proedure, nd rndom simultion ntively working on shred grph representtion of the prolem. The desried intertwined integrtion of the four tehniques results in powerful summtion of their orthogonl strengths. The presented resoning tehnique ws minly developed for forml equivlene heking nd property verifition ut n eqully e used in other CAD pplitions. Our experiments demonstrte the effetiveness of the pproh for rod set of pplitions. Index Terms Boolen resoning, BDD, SAT, forml verifition, equivlene heking, property heking. I. INTRODUCTION MANY tsks in omputer-ided design suh s equivlene or property heking, logi synthesis, timing nlysis, nd utomti test-pttern genertion require Boolen resoning on prolems derived from iruit strutures. There re two min pprohes used lterntively for suh pplitions. First, y onverting the prolem into funtionlly nonil form suh s Binry Deision Digrms (BDDs), the solution n e otined from the resulting digrm. Seond, struturl stisfiility (SAT) proedures perform systemti serh for onsistent ssignment on the iruit representtion. The serh either enounters solution or, if ll ses hve een enumerted, onludes tht no solution exists. Both pprohes generlly suffer from exponentil worst-se omplexity. However, they hve distint strengths nd weknesses whih mke them pplile to different lsses of prtil prolems. A monolithi integrtion of SAT nd BDD-sed tehniques ould omine their individul strengths nd result Mnusript reeived Month xx, ; revised Month xx,. This pper ws reommended y Assoite Editor Nme Nme. A. Kuehlmnn is with the Cdene Berkeley Ls, Berkeley, CA 97, USA (e-mil: kuehl@dene.om). V. Pruthi is with the IBM Enterprise Systems Group Austin, T 7878, USA (e-mil: vpruthi@us.im.om). F. Krohm is with the IBM Miroeletroni Division Hopewell Juntion, NY, USA (e-mil: florin@edmil.fishkill.im.om). M. K. Gni is with the NEC C&C Reserh Ls Prineton, NJ 8, USA (e-mil: mly@ne-l.om). in powerful solution for wider rnge of pplitions. Additionlly, y inluding rndom simultion its effiieny n e further improved for prolems with mny stisfying solutions. A lrge frtion of prtil prolems derived from the ove mentioned pplitions hve high degree of struturl redundny. There re three min soures for this redundny: First, the primry netlist produed from register trnsfer level (RTL) speifition ontins redundnies generted y lnguge prsing nd proessing. For exmple, in industril designs, etween nd % of generted netlist gtes re redundnt []. A seond soure of struturl redundny is inherent to the tul prolem formultion. For exmple, miter struture [], uilt for equivlene heking, is glolly redundnt. It lso ontins mny lol redundnies in terms of identil sustrutures used in oth designs to e ompred. A third soure of struturl redundny origintes from repeted invotions of Boolen resoning on similr prolems derived from overlpping prts of the design. For exmple, the individul pths heked during flse pths nlysis re omposed of shred su-pths whih get repetedly inluded in susequent heks. Similrly, omintionl equivlene hek of lrge designs is deomposed into series of individul heks of output nd next-stte funtions whih often shre lrge prt of their struture. An pproh tht detets nd reuses struturl nd lol funtionl redundnies during prolem onstrution ould signifintly redue the overhed of repeted proessing of identil strutures. Further, tight integrtion with the tul resoning proess n inrese its performne y providing mehnism to effiiently hndle lol deisions. In this pper we present n inrementl Boolen resoning pproh tht integrtes struturl iruit trnsformtion, BDD sweeping [], iruit-sed SAT proedure, nd rndom simultion in one frmework. All four tehniques work on shred AND/INVERTER grph [] representtion of the prolem. BDD sweeping nd SAT serh re pplied in n intertwined mnner oth ontrolled y resoure limits tht re inresed during eh itertion []. BDD sweeping inrementlly simplifies the grph struture, whih effetively redues the serh spe of the SAT solver until the prolem n e solved. The set of iruit trnsformtions get invoked when the sweeping uses struturl hnge, potentilly solving the prolem or further simplifying the grph for the SAT serh. Furthermore, rndom simultion n effiiently hndle prolems with dense solution spes. This pper is strutured s follows. Setion II summrizes previous work in the re nd ontrsts it to our ontriutions. Setion III presents the AND/INVERTER grph representtion, whih is shred mong ll resoning mehnisms nd outlines

2 IEEE TRANSACTIONS ON COMPUTER-AIDED DESIGN OF INTEGRATED CIRCUITS AND SYSTEMS, VOL., NO. Y, MONTH the set of trnsformtions tht re pplied for its simplifition. Setion IV presents the BDD sweeping lgorithm nd Setion V outlines the detils of the iruit-sed SAT proedure. The rndom simultion lgorithm nd overll resoning flow re desried in setions VI nd VIII, respetively. The lst two setions present experimentl results nd onlusions. II. PREVIOUS WORK SAT serh hs een extensively reserhed in multiple ommunities. Mny of the pulished pprohes re sed on the Dvis-Putnm proedure [], [6], whih exeutes systemti se split to exhustively serh the solution spe. Over the yers, mny serh ttis improvements hve een pulished. The most notle implementtions of CNF-sed SAT solvers re GRASP [7] nd Chff [8]. Clssil CNF-sed SAT solvers re diffiult to integrte with BDD methods nd dynmilly pplied iruit trnsformtions euse they use luse-sed representtion of the prolem. In this pper we desrie n implementtion of SAT proedure tht works diretly on n AND/INVERTER grph llowing tight intertion with BDD sweeping, lol iruit grph trnsformtions, nd rndom simultion. We desrie modified implementtion of non-hronologil ktrking nd onflit-sed lerning nd present n effiient mens to sttilly lern implitions. Trding off omptness of Boolen funtion representtions with noniity for effiient resoning in CAD pplitions hs een the sujet of mny pulitions. BDDs [9], [] mp Boolen funtions onto nonil grph representtions nd thus re one extreme of the spetrum. Deiding whether funtion is tutology n e done in onstnt time, t the possile expense of n exponentil grph size. BDDs [] propose to divert from the strit funtionl noniity y dding funtion nodes to the grph. The node funtion is ontrolled y n ttriute on the referening r nd n represent n AND or OR opertion. Similr to BDDs, the funtionl omplement is expressed y seond r ttriute nd struturl hshing identifies isomorphi sugrphs on the fly. The proposed tutology hek is similr to tehnique presented in [] nd is sed on reursive inspetion of ll oftors. This sheme effetively heks the orresponding BDD rnhing struture sequentilly, resulting in exponentil runtime for prolems for whih BDDs re exessively lrge. Another form of non-nonil funtion grph representtion re BEDs []. BEDs use iruit grph with six possile vertex opertions. The innovtive omponent of BEDs is the pplition of lol funtionl hshing, whih mps ny four-input su-struture onto nonil representtion. Tutology heking is sed on onverting the BED struture into BDD y moving the vriles from the ottom of the digrm to the top. Similr to mny pure utpoint-sed methods, this pproh is highly sensitive to the ordering in whih the vriles re pushed up. In our pproh, we pply n extended funtionl hshing sheme to n AND/INVERTER grph representtion. Sine our grph preserves the AND lustering, the hshing n tke dvntge of its ommuttivity whih mkes it less sensitive to the order in whih the struture is uilt. If the struturl method fils, we pply BDD sweeping on the iruit grph for heking tutology. Due to the multiple frontier pproh desried lter, it is signifintly more roust thn the BED to BDD onversion proess. There re numerous pulitions proposing the pplition of multiple methods to solve diffiult resoning instnes. For exmple, in [] nd [] the uthors presented rndom simultion lgorithm nd the erlier mentioned method sed on struturl hshing nd BDDs, respetively, nd suggested their pplition in multi-engine setting. In [] omprehensive filter-sed pproh is desried tht suessively pplies multiple engines inluding struturl deomposition, BDDs, nd ATPG to solve omintionl equivlene heking prolems. All these tehniques hve in ommon tht they pply multiple, speilized tehniques in sequentil, independent mnner. In ontrst, the presented pproh tighly intertwines the use of struturl methods, BDD-sed tehniques, nd SAT serh nd pplies them on single uniform dt representtion. The proposed setting llows n utomti dpttion of the omined lgorithm to mth given prolem struture tht results in signifint inrese in the overll resoning power. Severl pulitions hve suggested n integrtion of SAT nd BDD tehniques for Boolen resoning. Cutpoint-sed equivlene heking uses sptil prolem prtitioning nd n e employed s se to pply SAT nd BDDs in distint prts of the miter struture. A prtiulr pproh [6] first uilds prtil output BDD strting from the utset where uxiliry vriles re introdued. It then enumertes the onset ues of this BDD nd pplies SAT serh for justifying those ues from the primry inputs. This method eomes intrtle if the BDD inludes mny ues in its onset. Further, the tul justifition of individul ues my timeout if the utset is hosen unwisely. A modifition of this pproh suggests to serh through ll o-ftors of the BDD insted of enumerting ll ues [7]. Another proposl to omine BDD nd SAT is sed on prtitioning the iruit struture into set of omponents [8]. As most utpoint-sed methods, ll these pprohes re highly sensitive to the hosen prtitioning. A ommon prolem with the mentioned integrtion pprohes is the insertion of BDD opertions into the inner loop of struturl SAT serh. Struturl SAT is effiient if the underlying prolem struture n e exploited for effetive lol serh heuristis. BDDs work well if redundny of the prolem struture eludes n exponentil growth during onstrution. A sptil prtitioning of the pplition spe for BDDs nd SAT lurs their individul glol sope nd seprtes the pplition of their orthogonl strengths to different prts. In this pper we pply BDD sweeping nd struturl SAT serh, oth working in n interleved mnner on the entire prolem representtion. This keeps oth mehnisms foused on the glol struture without eing onstrined y n ritrry preprtitioning. In this setting, BDD sweeping inrementlly redues the serh spe for the SAT solver until the prolem is solved or the resoure limits re exhusted. Struturl trnsformtions re used to filitte lol deisions. III. PROBLEM REPRESENTATION AND STRUCTURAL TRANSFORMATIONS In this setion we desrie the si AND/INVERTER grph representtion tht is employed s underlying dt struture for

3 KUEHLMANN ET AL.: BOOLEAN REASONING FOR FORMAL EQUIVALENCE CHECKING AND FUNCTIONAL PROPERTY VERIFICATION ll Boolen resoning lgorithms desried in the following setions. We lso present severl hshing shemes tht remove struturl nd lol funtionl redundnies during grph onstrution. A. AND/INVERTER Grph Representtion nd Struturl Hshing A direted yli grph is used s struturl representtion of the funtions to e resoned out. There re three types of grph verties: A unique terminl vertex represents the onstnt ( ) vlue when it is referened y non-omplemented (omplemented) r. A seond type of vertex hs no inoming rs nd models primry inputs. The third vertex type hs two inoming rs nd represents the AND of the vertex funtions referened y the two rs. INVERTER ttriutes on the grph rs indite Boolen omplementtion. Using this grph representtion, resoning prolem is expressed s n oligtion to prove prtiulr grph vertex to e onstnt or. Similr to the onstrution of BDDs, the AND/INVERTER grph is uilt from the inputs towrd the outputs using set of onstrution opertors. There re three si onstrutors: () rete_input, () rete_nd, nd () rete_inverter. Other opertors for lterntive or more omplex opertions re omposed of these si onstrutors. Intermedite funtions re pssed etween onstrutors y r hndles, whih onsist of referene to the soure vertex nd possile INVERTER ttriute. The sme hndles re pplied y the resoning pplition to refer to funtions tht re stored y the grph. Algorithm rete_nd( ) Fig.. /* onstnt folding */ if ( == CONST_) return CONST_; if ( == CONST_) return CONST_; if ( == CONST_) return ; if ( == CONST_) return ; if ( == ) return ; if ( == ) return CONST_; /* rnk order inputs to th ommuttivity */ if (rnk( ) > rnk( )) swp( /* hek for isomorphi entry in hsh tle */ if (( = hsh_lookup( )) == NULL) = new_nd_vertex( return ; Algorithm rete_nd for the AND onstrutor. The implementtion of the onstrution opertion rete_input is stright forwrd. It llotes nd initilizes orresponding vertex dt struture nd returns hndle pointing to it. Similrly, the opertion rete_inverter simply toggles the ttriute of the hndle. Fig. shows the pseudoode for the opertion rete_nd. The lgorithm tkes two r hndles s input prmeters nd returns n r hndle tht represents the output of the AND opertion. In the ode, the symol denotes Boolen omplemention using the proedure rete_inverter. The first prt of the lgorithm performs onstnt folding, whih utomtilly simplifies redundnt nd trivil expressions in the grph struture. Next hsh-lookup identifies isomorphi grph strutures nd elimintes them during onstrution. For this the proedure hsh_lookup heks whether n AND vertex with the requested input rs hs een reted efore. If found the existing vertex is reused, otherwise new vertex is reted using the funtion new_nd_vertex. Before pplying the hsh-lookup the two opertors nd re ordered using unique rnking riteri. This ssures tht ommuttive expressions, suh s nd, re merged onto the sme grph vertex. Algorithm new_nd_vertex( ) /* reshedule vertex for BDD sweeping */ put_on_hep(dd_from_vertex( ), "!$# _%'& (! _)*& +,& - put_on_hep(dd_from_vertex( ), "!$# _%'& (! _)*& +,& - /* lern implition shortuts for SAT */ if (hsh_lookup(, )) lern( if (hsh_lookup(, )) lern(. = llo_vertex( dd_to_hsh_tle( return ; Fig.. Algorithm new_nd_vertex for lloting new grph vertex, inluding restrting of BDD sweeping (Setion IV) nd stti lerning (Setion V). The lgorithm new_nd_vertex is shown in Fig.. It is used to llote new grph vertex nd dd orresponding entry to the hsh tle. This proedure lso hndles the re-tivtion of the BDD sweeping lgorithm nd stti lerning s desried in setions IV nd V, respetively. The onstrution of the AND/INVERTER grph for simple exmple is illustrted in Fig.. Prt () represents iruit uilt for proving equivlene of nets / nd, whih re funtionlly identil ut hve different struturl implementtions. Funtionlly equivlent nets re leled using identil numers with one or more postrophes. Fig. () shows the result of the grph onstrution using the lgorithm rete_nd of Fig.. The verties of the grphs represent AND funtions nd the filled dots on the rs symolize the INVERTER ttriutes. Note tht in severl ses struturlly isomorphi nets re mpped onto the sme grph verties. For exmple, the funtions (net 6 of the upper iruit) nd 7 (net of the lower iruit) re identified s struturlly equivlent nd represented y single vertex. B. Funtionl Hshing The simple two-level hshing sheme of lgorithm rete_nd n eliminte struturlly isomorphi grph verties ut nnot hndle funtionlly identil verties tht re implemented y different strutures. For exmple, the equivlene of verties / nd of the iruit in Fig. nnot e shown y simple hshing. In this setion we present generlized hshing sheme tht identifies funtionlly identil suiruits of ounded size independent of their tul struturl implementtion. A nturl wy to inrese the sope of struturl hshing would e to divert from the two-input grph model nd use verties with higher fnin degree. The set of possile funtions of vertex with more thn two inputs nnot e enoded effiiently using uniform vertex opertions nd r ttriutes only. Insted the vertex funtion should e represented y n ttriute whih is hshed in onjuntion with the input referenes to find

4 IEEE TRANSACTIONS ON COMPUTER-AIDED DESIGN OF INTEGRATED CIRCUITS AND SYSTEMS, VOL., NO. Y, MONTH Fig.. d d d d () () () (d) Exmple for the onstrution of n AND/INVERTER grph: () funtionlly redundnt struture generted to hek funtionl equivlene of outputs : nd ;, () orresponding two-input AND/INVERTER grph uilt y lgorithm rete_nd of Fig., () lterntive grph representtion with fourinput verties, (d) resulting two-input grph fter funtionl hshing using the lgorithm rete_nd of Fig.. struturlly identil iruit prts. Sine the numer of possile vertex funtions grows exponentilly, this method is only prtil for verties with up to four inputs. For the iruit exmple of Fig. (), prt () shows the grph model sed on verties with mximum fnin degree of four. Note tht this method n identify the equivlene of the net pir ut still fils to show the sme for pir <BA?A"8@, nd therefore for / nd x y x y x y x y A more omprehensive pproh denoted s funtionl hshing [] is sed on the presented two-input grph nd n extension of the struturl nlysis tht inludes the two grph levels preeding vertex. As result the grnulrity of identifying funtionlly identil verties is omprle to the grnulrity of the hshing tehnique sed on four-input verties. Moreover, y pplying this method on ll intermedite verties in n overlpping mnner, this pproh n tke dvntge of dditionl struturl similrities tht otherwise remin internl to four-input verties. Algorithm rete_nd( ) /* onstnt folding */ if ( == CONST_) return CONST_; if ( == CONST_) return CONST_; if ( == CONST_) return ; if ( == CONST_) return ; if ( == ) return ; if ( == ) return CONST_; /* rnk order inputs */ if (rnk( ) > rnk( )) swp( /* hek for isomorphi entry in hsh tle */ if (( = hsh_lookup( )) == NULL) /* ses depending on position in grph */ if (is_vr( ) && is_vr( )) = new_nd_vertex( else if (is_vr( )) = rete_nd( else if (is_vr( )) = rete_nd( else = rete_nd( return ; Fig.. Algorithm rete_nd for n AND onstrutor tht inludes lol funtionl hshing. Fig. outlines the overll flow of the funtionl hshing sheme. The first prt, whih performs onstnt folding nd struturl hshing, is identil to the lgorithm rete_nd of Fig.. In se of hsh miss, the seond prt inludes n extended two-level lookup sheme, whih onverts the lol funtion of the four grndhildren into nonil representtion. During grph onstrution from the primry inputs, the first level of verties does not hve four grndhildren nd, thus, must e treted speilly. If oth immedite hildren re primry inputs, the lgorithm retes new vertex using the proedure new_nd_vertex, whih is shown in Fig.. If only one of the hildren is primry input, nonil three-input sustruture is reted y pplying the proedure rete_nd, nd for the remining se the proedure rete_nd is lled. Sine the lgorithms of the proedures rete_nd nd rete_nd re quite similr we limit the desription to the ltter. Its pseudo-ode is given in Fig.. The proedure of rete_nd simply implements suset of the shown ses. The lgorithm rete_nd first nlyzes the lol sustruture using the proedure nlyze_se. It omputes signture whih reflets () the equlity reltionship of the four grndhildren nd () the inverter ttriutes of the six rs. This signture is mpped to one of C"D= different ses (for the lgorithm rete_nd, the signture is mpped to one of EE ses). By onstrution, the topology of the sustruture is uniquely identified y this signture. Its vlue is then mpped onto n implementtion index suh tht ll strutures with iden-

5 KUEHLMANN ET AL.: BOOLEAN REASONING FOR FORMAL EQUIVALENCE CHECKING AND FUNCTIONAL PROPERTY VERIFICATION Algorithm rete_nd() F# ) )G) = ) ->)!H - ; ) # = ) -> # & IJK- ; # ) = # ->)! H - ; # # = # -> # & IJK- ; &L M! : = nlyze_se() ># swith(&l M! : ) NON'N se PQ : /* funtion I in Fig. 6 */ = rete_nd()) ) # /* reursive */ = rete_nd(r)g) S) # return rete_nd( /* not reursive */ NON'N se T'UV : /* funtion J in Fig. 6 */ = rete_nd()) ) # = rete_nd(r)g) S) # return rete_nd( NON'N se TOWW : /* exmple of Fig. 7 */ return rete_nd( # ) F# # NON'N /* remining ses with no redution */ return new_nd_vertex() # Fig.. Sketh of the lgorithm rete_nd whih hndles vertex onstrution for sustrutures with four grndhildren. til funtions get projeted onto the sme index. For eh distint index new nonil implementtion is then generted. Beuse of this noniity nd the pplied vertex hshing this method merges ll funtionlly equivlent sustrutures, effetively removing lol funtionl redundnies. Fig. provides pseudo-ode exmples to hndle ses Y Z nd 69C"D, whih represent the strutures of n OR nd NOR funtion s shown in Fig. 6(). Prt () of this figure demonstrtes how funtionl hshing mps oth funtions onto the sme vertex referened y omplemented rs. () 6 g h () Fig. 6. Exmple for merging the strutures of funtions I[ OR\] F^O_ nd J`[ NOR\ ] F^O_ using the lgorithm rete_nd: () resulting struture without funtionl hshing, () struture with funtionl hshing. Note tht funtionl hshing is pplied reursively s shown in the implementtion of the intermedite funtions nd of ses Y Z nd 69C"D of Fig.. However, to ensure termintion, the finl vertex must e onstruted with the non-reursive proedure rete_nd shown in Fig.. The reursive pplition of funtionl hshing often results in signifint grph redution. For exmple, the two outputs in Fig. () n e merged y funtionl hshing resulting in the grph shown in prt (d). C. Lol Rewriting Funtionl hshing, s desried in the previous susetion, hs the potentil to ompt grph representtions for strutures with shred grndhildren. However, if ll four grndhildren of the two opernds re distint, the hshing does not g h result in ny struturl redution. Still, in some ses where the opernd s grnd-grndhildren re shred, the lol struture n e rerrnged suh tht they shre t lest one grndhild. This rerrngement will enle following funtionl hshing step. For exmple, the expression nnot e simplified with funtionl hshing euse it hs four distint grndhildren, k9? l? mnl?$jko. However, fter rewriting the expression into np<$<eq@ <eq@'@ qj@ funtionl hshing n simplify the struture to rstuvuj. The orresponding step-wise grph trnsformtions re illustrted in Fig. 7. Fig. 7. rr l rl () r g () Exmple of lol rewriting: () originl grph tht nnot e redued y funtionl hshing, () result of rewriting using se UVw of lgorithm rete_nd (Fig. 8), () result fter reursive pplition of se TOWW of lgorithm rete_nd (Fig. ). To hndle lol rewriting, the lgorithm rete_nd is enhned y reognizing more ses in the proedure nlyze_se nd dding the orresponding indies to the implementtion ses. In essene, the mentioned rewriting mehnism is pplile if: () t lest one opernd of the AND opertion is omplemented nd () the grndhildren nd/or hildren of the opernds re shred. Fig. 8 shows modified version of the lgorithm rete_nd tht inludes the dditionl D ses for lol rewriting. The proedure shre tests whether two given verties shre ny hildren. In the given exmple of Fig. 7, the left hild of vertex is inverted nd shres its hildren with the right-left grndhild of. Here the depited se C"D x of the modified lgorithm of Fig. 8 is pplied for rewriting. During the implementtion step the proedure rete_nd is lled reursively fter whih se 6.E E shown in Fig. is pplile nd simplifies the grph to the struture given in Fig. 7(). D. Symmetri Cluster Hshing The previously desried methods, inluding struturl hshing, funtionl hshing, nd lol rewriting restruture the AND/INVERTER grph only lolly y exmining limited numer of fnin verties. A further ompression of the grph n e hieved y nlyzing igger symmetri grph lusters. The ide is tht expression trees utilizing uniform symmetri vertex funtion (e.g., AND or OR) represent the sme Boolen funtion if they hve identil sets of soure verties. This equivlene is independent of the tul tree struture nd permuttion of soures. For identifying identil symmetri luster funtions, speil luster hshing lgorithm is pplied whenever new AND vertex is uilt. The lgorithm trverses the trnsitive fnin of g () g

6 6 IEEE TRANSACTIONS ON COMPUTER-AIDED DESIGN OF INTEGRATED CIRCUITS AND SYSTEMS, VOL., NO. Y, MONTH Algorithm rete_nd() e# ) )) = ) ->)!H - ; ) # = ) -> # &I.JK- ; # ) = # ->)! H - ; ## = # -> # & IJK- ; & L M! : = nlyze_se() F# swith(& L M! : ) N'NON /* rewriting ses */ se UVy : /* l nd r re inverted */ N'NON se UVw : /* only l is inverted */ if (shre() F# ) ) shre()g) ># ) ) shre() # F# ) )) return rete_nd(rete_nd() F# ) ), # # ) if (shre() F## ) shre()g) e## ) shre() # >## )) return rete_nd(rete_nd() F## ), # ) ) if (shre()) F# ) shre() # F# )) return rete_nd( rete_nd(r)g) e# ), rete_nd(r) # e# ) Fig. 8. rek; se UV z : /* only r is inverted */ N'NON /* no redution or rewriting */ return new_nd_vertex() ># Sketh of improved lgorithm rete_nd with lol rewriting. the vertex, determines the oundries of the symmetri expression tree, nd ollets the set of soure verties. This set is then hshed using speil luster hsh tle. If identil entries re found, the orresponding verties re merged nd their fnout strutures re reuilt. The symmetri luster hshing is done for two funtion types. AND lusters re simple to identify y just trversing the fnin struture until inverted rs re enountered. Due to their dulity, OR lusters re utomtilly hndled y the sme lgorithm. OR/NOR lusters re found y reursively serhing for the nonil OR struture (shown in Fig. 6). Only one of the two possile OR/NOR needs to e identified, sine the other struture gets rewritten y funtionl hshing. Note tht n lterntive pproh to hndle symmetri lusters would e to uild AND nd OR expression trees in nonil mnner, for exmple, y lwys uilding lned tree struture using the soure verties in some lexiogrphil order. However, our experiene is tht suh n pproh is inferior to the presented method sine it destroys up-font lrge prts of the existing (empirilly useful) iruit struture nd s result prevents mny mthings tht re otherwise possile. IV. BDD SWEEPING In this setion we desrie the BDD sweeping lgorithm, method tht systemtilly identifies nd merges funtionlly equivlent AND/INVERTER grph verties tht re not found to e equivlent y the previously desrie struturl methods. The sweeping method uilds BDDs for the individul grph verties strting from inputs nd multiple ut frontiers towrd the outputs. By mintining ross-referenes etween the grph verties nd its BDD nodes, funtionlly identil verties n e found onstrutively during the sweep. There re severl key ides tht mke BDD sweeping roust nd effiient: { As soon s two funtionlly equivlent verties re identified, their output strutures re merged nd rehshed using the lgorithms desried in the previous setion. The instntneous pplition of struturl simplifition n solve resoning prolems without uilding BDDs for the entire prolem struture, resulting in signifint inrese in the overll resoning power nd performne. { The BDD propgtion is prioritized y the tul size of the input BDDs using hep s proessing queue. As result, the sweeping lgorithm fouses first on inexpensive BDD opertions nd voids the onstrution of lrge BDDs unless they re needed for solving prolem. { The mximum size of the proessed BDDs is limited y threshold, whih effetively ontrols the omputing resoures nd resoning power. BDDs tht exeed the size of the threshold re hidden in the proessing hep nd will repper when the sweeping is restrted with suffiiently lrge limit. This mehnism is used to interleve BDD sweeping with struturl SAT serh. By inrementlly inresing the resoures of the individul lgorithms during eh itertion, their resoning power ontinues to grow until the prolem n e solved y either one of them. { Multiple BDD frontiers re onurrently propgted in the hep ontrolled mnner. This pproh effetively hndles lol redundnies without the need to lwys uild lrge BDDs from the grph inputs. { When the BDD proessing rehes ny of the trget verties tht represent proof oligtion (i.e., it must e shown to e onstnt, or not) one of the following steps is pplied: If the orresponding BDD represents onstnt, the vertex gets merged with the onstnt grph vertex nd the resoning result is ovious (depending on the prolem either SAT or UNSAT). Otherwise, if the support of the BDD ontins only primry input vriles, stisfiility is proven nd ny pths from the BDD root to the orresponding onstnt BDD node n serve s ounterexmple. If the support ontins vriles from intermedite utsets, flse negtive resolution is pplied. A. Bsi Sweeping Algorithm Fig. 9 shows the self-explntory pseudo-ode for the si BDD sweeping lgorithm dd_sweep. It does not inlude the proessing of multiple BDD frontiers, whih is desried in the next susetion. The hep struture is initilized in the overll proedure (see Setion VIII). For this, primry inputs re initilized t the eginning of the resoning flow using the proedure sweep_init, wheres utset verties re delred nd initilized etween the individul sweeping itertions. The invotion of the sweeping lgorithm proesses ll hep BDDs tht hve smller size thn the given threshold _}e~l. _ƒ. _} B >ˆ. All lrger BDDs remin hidden in the hep nd get proessed when the lgorithm is lled gin with suffiiently lrge threshold. During eh itertion of the inner sweeping loop, the lgorithm removes the smllest BDD from the hep, proesses the Boolen opertions for the immedite fnout struture of the orresponding iruit grph vertex, nd reenters the resulting BDDs onto the hep, if their size is elow the threshold _Š 9 _ƒ. _} B >ˆ.

7 KUEHLMANN ET AL.: BOOLEAN REASONING FOR FORMAL EQUIVALENCE CHECKING AND FUNCTIONAL PROPERTY VERIFICATION 7 Algorithm sweep_init(!'# -! : ) J! ] = new_hep( for ll input verties Œ do ^ M M = rete_dd_vrile( store_vertex_t_dd(^ MM ŒG put_on_hep(j! ] F^ M M >^ M M _ "!$# _%'&Ž(! _)G&+ & - return J! ] ; Algorithm dd_sweep(j! ]!$# -! : ) /* hek if there re ny BDDs on hep with size(^ M M ) ^ M M _)G!$# _%O&Ž(! _)*& +,& - */ while (!is_hep_empty(j! ], ^ MM _)G!'# _%O&Ž(! _)*& +,& - )) do ^ M M = get_smllest_dd(j! ] = get_vertex_from_dd(^ M M /* hek if previously enountered */ if (get_dd_from_vertex( )) ontinue; store_dd_t_vertex( '^ M M for ll fnout_verties ' of do ^ M M = get_dd_from_vertex( ' ->)! H - ^ M M ŒGš = get_dd_from_vertex( ' -> # & IJK- ^ M M Bœ = dd_nd(^ M M >^ MM Œ*š Bœ = get_vertex_from_dd(^ M M Bœ if ( >œ ) merge_verties( >œ ' Fig. 9. /* return if prolem solved */ if (!'# -! : == CONST_) return SAT; == CONST_) return UNSAT; if (!'# -! : else store_vertex_t_dd(^ M M Bœ '. /* BDD for Bœ nnot e onstnt */ if ( $ ==!'# -! : ) return SAT; put_on_hep(j! ] >^ M M Bœ >^ M M _ "!$# _%'&Ž(! _)G& +,& - return UNDECIDED; Initiliztion proedure sweep_init nd si BDD sweeping lgorithm dd_sweep for deiding Sž Ÿ \!$# -! : _. Using ross-referening etween grph verties nd the orresponding BDD nodes, funtionlly equivlent verties n e identified. An equivlent vertex pir is found if the result " O of BDD opertion lredy refers to nother vertex tht ws proessed efore. In this se oth verties re merged immeditely nd their susequent prts of the grph re rehshed y the proedure merge_verties. The rehshing is pplied in depth-first order strting from the merged verties towrd the primry outputs nd stops if no further reonvergeny ours. As result, the forwrd rehshing my merge the resoning trget vertex 9 lô 9/ with the onstnt vertex, effetively deiding the prolem. The orresponding two heks in the inner loop test for these ses. Before the BDD is reentered onto the hep, nother hek tests whether the trget vertex ws rehed. In this se the trget vertex must e non-onstnt, otherwise it would hve een merged with onstnt vertex nd one of the previous tests would hve sueeded. Therefore, the prolem is stisfile sine the BDD support inludes only primry input vriles. The following remrks further explin prtiulr detils of the sweeping lgorithm: { The sequene y whih the ross-referening is performed nd heked using the proedure get_dd_from_vertex, store_dd_t_vertex, get_vertex_from_dd, nd store_vertex_t_dd, ensures tht ll verties re hndled extly one, unless new grph verties re dded to the fnout of n lredy proessed vertex. In this se the proedure new_nd_vertex restrts the sweeping proess for these verties. { If one of the two BDD opernds is missing, the BDD opertion is skipped nd proessing ontinues with the next BDD from the hep. Note tht s soon s this opernd is ville, the sme BDD opertion will e re-invoked. { The merging of two verties is done in forwrd mnner, i.e., the fnouts of the vertex, whih is topologilly frther from the primry inputs must e reonneted to the vertex tht is topologilly loser to the inputs. Otherwise, the merge opertion my use struturl loops in the grph, whih would invlidte its semnti. Fig. illustrtes the mehnism of BDD sweeping for proving equivlene of two funtionlly identil ut struturlly different iruit ones. Prts () nd () show the miter struture of the two ones = nd = 8 to e ompred with n NOR gte nd the orresponding AND/INVERTER grph, respetively. The following figures show the progress of the sweeping until equivlene is proven. It is ssumed tht the BDDs re proessed in the order of their orresponding verties 6? CS?$DR?'ER? D 8Ž? nd C 8. The first four itertions rete the BDDs for verties 6? CS?$DR? nd E. In the next itertion, the resulting BDD node for vertex D8 lredy points to the funtionlly equivlent vertex D. Therefore, verties D8 nd D re merged s depited in Fig. (). The next figure shows the grph fter vertex C"8 hs een proessed nd merged with vertex C. The susequent forwrd rehshing identifies tht = nd = 8 re isomorphi nd merges them, whih further uses x to e merged with the onstnt vertex. Note tht for simpliity we used only struturl hshing in this exmple. The resulting grph struture is shown in Fig. (e). At this point funtionl equivlene is proven nd the lgorithm termintes without hving to uild BDDs for the entire miter struture. B. Enhned Sweeping Algorithm with Multiple BDD Frontiers The si sweeping lgorithm s desried in the previous setion strts the BDD propgtion from the input verties only. As result the size threshold of the BDD proessing preludes full penetrtion of deeper AND/INVERTER grphs. An enhned sweeping pproh is sed on multi-lyered propgtion of BDDs tht strt from the primry inputs s well s intermedite ut frontiers. Using this sheme, the grph verties re generlly ssoited with multiple BDDs tht represent their funtion from different uts of their fnin logi. For the multi-lyer BDD propgtion, the overll lgorithm, whih is desried in Setion VIII, delres utpoints etween individul sweeping steps. There re severl heuristis to identify verties tht represent effetive utpoints, inluding the use of: { verties tht hve lrge fnout, { verties tht hve multiple pths to the resoning vertex, { in se of equivlene heking, verties tht re on the order of the intersetion of the two ones tht form the miter struture.

8 8 IEEE TRANSACTIONS ON COMPUTER-AIDED DESIGN OF INTEGRATED CIRCUITS AND SYSTEMS, VOL., NO. Y, MONTH () () () (d) (e) CONST_ 6 Fig.. Exmple for BDD sweeping: () miter for two funtionlly identil iruit ones, () originl AND/INVERTER grph, () BDDs re omputed for verties,,,,, whih uses nd to e merged, (d) BDD is omputed for whih uses nd to e merged, (e) forwrd hshing uses nd to e merged nd 6 e merged with the onstnt vertex thus solving the resoning prolem get_dd_from_vertex returns the BDD stored for speified level t vertex. If the given level exeeds the ut level of the vertex, the BDD of the mximlly ville ut level is tken. Similr to the si lgorithm, speil heks re pplied when the BDD proessing rehes the trget vertex 9 9Ô 9/. However, sine the BDDs of the verties do not neessrily originte from the primry inputs, it nnot e deided immeditely if the prolem is solved. First, flse negtive resolution ttempts to re-sustitute utpoint vriles of the BDD with the BDDs driving the orresponding verties (see Setion IV-C). This my use the trget vertex to get merged with onstnt vertex in whih se the prolem is stisfile or unstisfile for merger with the onstnt or onstnt, respetively. Furthermore, if ll utpoint vriles hve een re-sustituted the resulting BDD origintes only from the primry inputs. The prolem must then e stisfile. Algorithm dd_sweep(j! ]!'# -! : ) while (!is_hep_empty(j! ] >^ M M _)G!$# _%O&Ž(! _)G& +,& - )) do ^ M M = get_smllest_dd(j! ] = get_vertex_from_dd(^ M M )!! ) = get_level_from_dd(^ M M if (get_dd_from_vertex( )!! ) )) ontinue; store_dd_t_vertex( O^ M M )!! ) for ll fnout_verties '. of do ^ M M = get_dd_from_vertex( '. ->)!H - )!! ) ^ M M Œ*š = get_dd_from_vertex( '. -> # &I.JK- )!! ) ^ M M >œ = dd_nd(^ M M B >^ M M ŒGš Bœ = get_vertex_from_dd(^ M M Bœ if ( Bœ ) merge_verties( Bœ '. if (!$# -! : == CONST_) return SAT; if (!$# -! : == CONST_) return UNSAT; else store_vertex_t_dd(^ M M Bœ $ store_level_t_dd(^ MM Bœ )!! ) if ( ' ==!$# -! : ) resolve_flse_negtive( if (!$# -! : == CONST_) return SAT; if (!$# -! : == CONST_) return UNSAT; /* non-onstnt level- BDD */ )) return SAT; if (get_dd_from_vertex(!'# -! : put_on_hep(j! ] F^ M M >œ B^ M M _!'# _%O&Ž(! _)*& +,& - return UNDECIDED; Fig.. Enhned BDD sweeping lgorithm with multi-lyered BDD frontiers for deiding Rž Ÿ±\!$# -! : _. Bsed on the delred utpoints, the ut level _level( ) of iruit grph vertex is reursively defined s follows: «ª if is primry input \Ž _ + ] : \ _level( ->)!H - ) [ «_level( -> # & IJ"- ))+ if is utpoint + ] : \ _level( ->)!H - ) _level( -> # & IJ"- )) otherwise. The ut level is used to define ut frontiers nd to lign the BDD propgtion with these frontiers. Fig. shows the modified sweeping lgorithm tht supports the hndling of multiple BDD frontiers. As shown, the dditions minly involve level-speifi hndling of BDDs. The proedure C. Flse Negtive Resolution The lgorithm to resolve flse negtives in shown in Figure. To fully explore BDDs onstruted for the different levels of the trget vertex without memory explosion, the elimintion proess is lso ontrolled y hep. In eh itertion, the smllest BDD is tken nd its topmost ut vrile resustituted y the orresponding driving funtion. The resulting BDD is then heked for funtionlly equivlent vertex tht hs een proessed efore. If found, oth verties re merged nd the susequent prts of the iruit grph re rehshed. Otherwise, if the size of the resulting BDD is smller thn the given limit, it is reentered onto the hep for further proessing.

9 KUEHLMANN ET AL.: BOOLEAN REASONING FOR FORMAL EQUIVALENCE CHECKING AND FUNCTIONAL PROPERTY VERIFICATION 9 Algorithm resolve_flse_negtives ( ) for )!! ) [ to _level ( ) do ^ M M = get_dd_from_vertex(, )!! ) put_on_hep(²o + %! _J! ], ^ M M )G& +,& - = ^ M M _)!$# _%'&Ž(! _)G&+ & - ; while (!is_hep_empty(²' $+ %! _J! ] )G& +,& - )) do ^ M M = get_smllest_dd(²o + %! _J! ] = get_vertex_from_dd(^ M M ^ M M³' = get_utvr_from_dd(^ M M if (^ M M³' ) ³$ = get_vertex_from_dd(^ M M ³$ )!! ) = _level ( ³$ ^ M M.µ = get_dd_from_vertex( ³$, )!! )K T ^ M M Bœ = dd_ompose(^ MM, ^ M M³', ^ M M µ Bœ = get_vertex_from_dd(^ M M >œ if ( Bœ ) merge_verties( Bœ, else store_vertex_t_dd (^ M M >œ, put_on_hep(²' $+ %! _J! ], ^ M M Bœ Fig.. Algorithm to eliminte flse negtives. A. Bsi SAT Proedure V. STRUCTURAL SAT SOLVER The struturl SAT solver is sed on the Dvis-Putnm proedure working on the presented AND/INVERTER grph. It ttempts to find set of onsistent vlue ssignments for the verties suh tht the trget vertex evlutes to logil. Unstisfiility is proven if n exhustive enumertion does not unover suh n ssignment. Fig. provides the top level view of the SAT lgorithm onsisting of two routines, the proedure st_init, nd the proedure justify, whih hndles the se splitting nd ktrking. The overll SAT serh is sed on proessing queue Šƒˆ O¹ j ˆ ~lº _»lš 9Š tht ontins ll verties for whih onsistent ssignment must e found. The lgorithm ttempts to sequentilly justify these verties using rnh-nd-ound se enumertion. Note tht due to their uniform AND funtionlity, only verties tht re to e justified to need to e sheduled on tht queue. A required logil t vertex output implies t oth of its inputs nd is hndled diretly y the proedure imply. Further, if the vlue of vertex output is not yet speified ( ) it does not need to e justified sine ny vlue setting t its inputs will led to onsistent setting. The proedure st_init first ssigns the trget vertex to nd propgtes ll implitions using the proedure imply. Unless the trget ssignment results in n immedite onflit it retes the first stk entry for the proedure justify. This entry ontins ll to-e-justified verties tht hve een olleted y imply. The following ll of the proedure justify then performs systemti se serh y reursively proessing ll queue verties nd enumerting for them ll vlid input ssignments (two for Boolen logi). In the se tht the ssignments of serh sutree result in onflit, mrking mehnism llows undoing ll ssignments up to tht deision level. The tight integrtion of the SAT solver into the overll frmework requires n exeution ontrol y providing resoure limits Algorithm st_init(!'# -! : ) %O- ].²O¼ = new_stk( ssign(!'# -! : T if (imply(!$# -! : )) M _)!! ) = push_on_stk(%'- ]²O¼,NULL M _)!! ) ->+] # ¼ = ; M _)!! ) ->½!! = ¾%'-Ž& H & ²'] -Ž&Ž L _½!! ; M _)!! ) -> = dequeue_vertex(m _)!! ) ->½!! return %O- ].²O¼ ; Algorithm justify(%'- ]²O¼ ) while (T ) if (^ ]²O¼9- # ]²O¼K% ++ > %']- _^ ]²O¼9- # ]²O¼ _)G&+ & - ) return UNDECIDED; M _)!! ) = pop_from_stk(%o- ].²O¼ if (!M _)!! ) ) return UNSAT; /* exhusted */ lel: if (!M _)!! ) -> ) return SAT; /* justified */ /* try ll vlues one y one; ontinue from lst vlue fter returning from higher deision level */ for ll vlues for M _)!! ) -> ].)*! do ssign(m _)!! ) -> ->)! H - M _)!! ) -> ].)*! if (imply(m _)!! ) -> ->)!H - )) M _)!! ) = push_on_stk(%'- ]²'¼ M _)!! ) M _)!! ) ->+] # ¼ = til_pointer(]9%$%'& I L+! L - _)G&Ž%'- M _)!! ) ->½!! = ¾ %O-Ž& H &Ž²O]-Ž& L _½!! ; M _)!! ) -> = dequeue_vertex(m _)!! ) ->½$!! goto lel; /* filed undo ssignments nd reset queue */ undo_ssignments(m _)!! ) ->+ ] # ¼ ¾ %O-Ž& H &Ž²O]-Ž& L _½!! = M _)!! ) ->½!! ; Fig.. Generl Dvis-Putnum SAT proedure for deiding Sž Ÿ \!$# -! : _. suh s the numer of ktrks. If during the urrent pplition of justify this numer exeeds given threshold, the SAT solver interrupts its serh nd returns ontrol to the lling proedure. This supports n interleved pplition of the SAT serh with BDD sweeping s desried in Setion VIII. Furthermore, y preserving the stte of the deision stk etween susequent invotions, the SAT lgorithm n ontinue its serh from the point it stopped erlier without repetedly serhing previously hndled sutrees. This reentrnt funtionlity is implemented in the proedure justify y heking the ktrk limit eh time the serh returns from higher deision level. If the limit is exeeded, the ontrol is returned to the lling, overll proess nd the ktrking is postponed until justify is lled gin. Note tht the setup of st_init ensures orret initiliztion of the first stk entry. The detils of the lgorithm imply for implition proessing re shown in Fig.. Its implementtion tkes speifi dvntge of the underlying AND/INVERTER grph struture y pplying n effiient tle-lookup sheme for propgting logi implitions. The routines imply nd imply_ux iterte over the AND/INVERTER grph nd determine t eh vertex ll implied vlues nd the diretions for further proessing. Fig. gives n exerpt from the implition lookup tle. As desried ove, for Boolen logi only one se, justifition request for logil t the output of n AND vertex,

10 IEEE TRANSACTIONS ON COMPUTER-AIDED DESIGN OF INTEGRATED CIRCUITS AND SYSTEMS, VOL., NO. Y, MONTH Fig.. Algorithm imply(!'# -! : ) for ll fnout_verties ' of!$# -! : do if (! imply_ux( $ )) return ; return imply_ux(!'# -! : Algorithm imply_ux(!$# -! : ) ])G! = get_vlue(!$# -! : )* ].)*! = get_vlue(!$# -! : ->)! H - # ])G! = get_vlue(!$# -! : -> # & IJK- ² ##! L - _%O- ]-! = \ ].)*! )G ])G! ># ])G! _ ; L! :K- _%'- ] -! = lookup(² ##! L - _%O- ]-! swith (]²-Ž&Ž L ) se STOP: return T ; se CONFLICT: return ; se CASE_SPLIT: enqueue_vertex(!$# -! : ¾ %O-Ž& H &Ž²O]-Ž& L _½!! return T ; se PROP_FORWARD: ssign(!'# -! : L! :K- _%'- ] -! -> ])G! for ll fnout_verties ' of!$# -! : do if (!imply_ux( $ )) return return T ; NON'N se PROP_LEFT_RIGHT: ssign(!'# -! : ->)!H - L! :K- _%'- ] -! ->)*.])*! ssign(!'# -! : -> # & IJ"- L! :K- _%'- ] -! -> #.])*! if (!imply(!$# -! : ->)! H - )) return if (!imply(!$# -! : -> # & IJK- )) return return T ; NON'N return T ; Implition proedure to the AND/INVERTER grph. requires sheduling new vertex on the Šƒ.ˆ O¹ j ˆ B~lº _»lš.š. All other ssignments result in one of three ses: () onflit ourred, in whih se the lgorithm returns nd ktrks, () further implitions re triggered, whih re proessed reursively, or () the vertex is fully justified, in whih se the proedure returns for proessing the next element from the Šƒ.ˆ O¹ Bjˆ ~lº _»lš 9Š. The lookup tle is progrmmle for different logis. For exmple, using different tle the proedure imply n eqully e pplied to implement prllel, one-level reursive lerning sheme using nine-vlued logi [9]. Due to its uniformity nd low overhed, the presented implition lgorithm is highly effiient. As n indition, on Pentium III lss mhine it n exeute severl hundred thousnd ktrks per seond on typil iruit strutures. For eing enefiil for the overll performne, ny gin tht is potentilly hieved through dditionl struturl nlysis must offset the resulting slowdown of the imply funtion. In [8] nd [] similr resoning is given for effiient implementtions of SAT nd ATPG lgorithms, respetively. B. Improvements for the SAT Proedure ) Conflit Anlysis: Advned SAT solvers use onflit nlysis to skip the evlution of ssignments whih re symmetri to previously enountered onflits [7]. Two mehnisms re used for this purpose: First, non-hronologil k- ; ; ; urrent_stte next_stte tion STOP CONFLICT CASE_SPLIT PROP_FORWARD PROP_LEFT_RIGHT Fig.. Exerpt of the lookup tle for fst implition propgtion pplied in the proedure imply of Fig.. trking skips the evlution of se lterntives if the orresponding se splitting vertex ws not involved in ny lowerlevel onflit. Seond, onflit-sed lerning retes dditionl implition shortuts, whih reflet the ssignments tht used onflit. These redundnt strutures result in dditionl implitions, whih detet susequent, symmetri onflits erlier. Conflit nlysis requires trking the logil impt of se split ssignments on the onflit points. Other implementtions (e.g., [7]) pply n implition grph for whih the nodes orrespond to vriles nd edges reflet single implition steps. In the given setting, the onflit grph mnipultion during eh step of the imply routine would severely impt its performne. To redue this penlty, we pply sheme tht diretly ollets the responsile se ssignments s side funtion of the implition proess. This mehnism uses onflit it-vetor where eh it represents se vertex in the deision tree. In other words, the its of this vetor represent the soure verties from whih implition sequenes were strted. The tle lookup in funtion imply is expnded to lso determine the ontrolling soures for the propgtion of the onflit it-vetors. The tul propgtion is done y word-wide OR opertions of these vetors during the implition sequene. As result, when onflit is rehed, the tive positions of the it-vetor reflet the deisions verties tht re responsile for this ssignment. This sheme redues the speed of the implition proess y typilly less thn %, penlty tht is esily offset y the verge gin. The resulting onflit it-vetors re used to ontrol the ktrking mehnism. If ll hoies of deision level result in onflit, the ktrk level is determined y the lowest level tht ws involved in onflit. This is implemented effiiently y it-vetor opertions. The omined onflit it-vetor reflets ll responsile ssignments for tht prt of the deision tree nd is pssed upwrd to the next ktrking level. Further, the onflit it-vetor is exmined for ompt luses to lern. Its funtion is diretly mpped onto AND/INVERTER grph struture representing tht onflit. To void exessively lrge lerned strutures, we pply vrile limittion similr to [7]. However, insted of just restriting the mximum numer of onflit vriles, we lso tke their

11 KUEHLMANN ET AL.: BOOLEAN REASONING FOR FORMAL EQUIVALENCE CHECKING AND FUNCTIONAL PROPERTY VERIFICATION ssignment into ount, effetively estimting the size of the eliminted deision sutrees. ) Stti Lerning: An effetive mehnism to exploit the struture of the AND/INVERTER grph is illustrted in Fig. 6. By reusing the vertex hsh tle pplied during grph onstrution, pir of verties tht implement the funtions nd n e deteted using two hsh lookups. This onfigurtion ours quite often in prtil designs, for exmple in multiplexer-sed dt exhnge iruits tht swith dt strems etween two soures nd two destintions. By dding two dditionl verties to the grph, n implition shortut n utilize the existing imply funtion. If logil is sheduled for oth output verties, the implition proedure n immeditely justify the entire struture nd ypss the two se splits. This lerning struture is reted sttilly nd integrted into the vertex llotion lgorithm new_nd_vertex, whih is shown in Fig.. Note tht the lerned verties re uilt using the regulr rete_nd routine whih my use dditionl iruit restruturing or lerning events. p p p () Fig. 6. Lerning for \ [ p _ À \ [ () _ Á \ [ struture, () struture with lerned implition shortut. VI. RANDOM SIMULATION _ : () originl Mny prolem instnes of Boolen resoning re stisfile nd hve dense solution spes. The most effetive pproh for finding stisfying ssignment for suh prolem is often sed on pure rndom simultion. The design of rndom simultion lgorithm is stright forwrd. In this setion we riefly desrie the detils of its implementtion in the given setting. The presented AND/INVERTER grph is highly suitle for n effiient word-prllel implementtion of rndom simultion. The pseudo ode for the orresponding lgorithmi flow is shown in Fig. 7. After ssigning rndom vlues to the primry input verties, levelized proessing using word-wide AND nd NOT instrutions propgtes the resulting ssignments towrd the trget verties. A hek for stisfiility of trget vertex is simply done y prllel omprison of its vlue with the zero word. Note tht y pplying proper referene ounting, only single vlue frontier needs to stored during their propgtion, whih results in suliner memory omplexity []. VII. INPUT CONSTRAINTS Mny Boolen resoning prolems require n effiient hndling of input onstrints, typilly referred to s don t res. For exmple, in omintionl equivlene heking, input onstrints express the Boolen suspe for whih the two designs under omprison hve to e funtionlly identil. The remining input omintions represent don t res for whih the funtions my differ. Other prolems tht require effiient proessing of input onstrints our during synthesis nd verifition of inompletely speified funtions. Algorithm simulte(!$# -! : ) for ll input verties Œ do set_vlue( Œ,rndom_word() simulte_ux( if (get_vlue(!$# -! : )!= else ) return SAT; return UNDECIDED; Algorithm simulte_ux() for ll verties in topologil order do Fig. 7. )G ])G! = get_vlue( ->)!H - # ].)*! = get_vlue( -> # & IJK- if (is_inverted( ->)! H - )) )* ].)*! = word_not()g ])G! if (is_inverted( -> # & IJK- )) # ].)*! = word_not( # ].)*! ].)*! = word_nd()* ].)*! F# ].)*! set_vlue(.])*! Rndom simultion lgorithm simulte. Input onstrints split the set of vlues t the primry inputs into two prts, the vlid or re set nd the invlid or don t re set. The prolem of Boolen resoning under input onstrints is to find onsistent ssignment within the re set. A onvenient method for expressing nd storing input onstrints in the given setting is sed on hrteristi funtions tht n e stored nd mnipulted s prt of the overll AND/INVERTER grph. The grph representtion for the hrteristi funtion n e uilt using the stndrd onstrutor opertions, whih re desried in Setion III. Its result is then sserted to e logil, mening tht ll input vlues tht evlute this funtion to re onsidered to e the re set. The simplest method for hndling input onstrints is sed on sheme tht first onjoins the onstrint verties with the trget vertex nd then pplies the resoning lgorithms on the resulting AND vertex. However, for struturl simplifition, BDD sweeping, nd rndom simultion, this pproh would result in signifint performne degrdtion, espeilly if the frtion of vlid ssignments is very smll. A more effiient method is to keep the hrteristi funtions of the input onstrints seprte nd to hndle them speifilly in eh resoning lgorithm. In the following setions we elorte on the mehnisms to hndle input onstrints y the individul resoning lgorithms. A. Struturl Representtion As mentioned efore, input onstrints re simply expressed s hrteristi funtions nd represented s verties in the AND/INVERTER grph. The resulting onstrint verties re mrked for speil hndling for the SAT solver, BDD sweeping, nd rndom simultion. Fig. 8 gives the pseudo ode for the lgorithm tht sserts grph vertex to onstnt. As shown, the lgorithm onsists of two prts: First, lol nlysis of the sserted vertex serhes for OR nd NOR strutures. If found, the input verties of these funtions re sserted to e equl y struturlly merging them with the sme merge funtion pplied for BDD sweeping (see Setion IV). Seond, if no OR or NOR is found, struturl onjuntive deomposition of the ssertion funtion is ttempted. This is done y reursively trversing the AND tree driving the sserted vertex.