CS 267: Automated Verification. Lecture 6: Binary Decision Diagrams. Instructor: Tevfik Bultan

Transcription

1 CS 267: Automated Verification Lecture 6: Binar Decision Diagrams Instructor: evfik Bultan

2 Binar Decision Diagrams (BDDs) [Brant 86] Reduced Ordered Binar Decision Diagrams (BDDs) An efficient data structure for representing Boolean functions (or truth sets of Boolean formulas) and manipulating them here are BDD packages available: (for eample CUDD from Colorado Universit) BDDs are a canonical representation for Boolean functions given two Boolean logic formulas and G, if and G are equivalent (i.e. if their truth sets are the same), then their BDD representations will be the same

3 BDDs for Smbolic Model Checking BDD data structure can be used to implement the smbolic model checking algorithm we discussed earlier BDDs support all the operations we need for smbolic model checking take conjunction of two BDDs take disjunction of two BDDs test equivalence of two BDDs test subsumption between two BDDs negate a BDD test if a BDD satisfiable test if a BDD is a tautolog eistential variable elimination

4 Binar Decision rees Given a variable order, in each level of the tree, branch on the value of the variable in that level. Eamples for boolean formulas on two variables Variable order:, alse

5 Reduced and Ordered Binar Decision Diagrams We are interested in Reduced and Ordered Binar Decision Diagrams Reduced: Merge all identical sub-trees in the binar decision tree (converts it to a directed-acclic graph) Remove redundant tests (if the false and true branches for a node go to the same place, remove that node) Ordered We pick a fi order for the Boolean variables: 0 < 1 < 2 < he nodes in the BDD are listed based on this ordering

6 BDDs Repeatedl appl the following transformations to a binar decision tree: 1. Remove duplicate terminals 2. Remove duplicate non-terminals 3. Remove redundant tests hese transformations transform the tree to a directed acclic graph

7 Binar Decision rees vs. BDDs alse

8 Good News About BDDs Given BDDs for two boolean logic formulas and G he BDDs for G and G are of size G (and can be computed in that time) he BDD for is of size (and can be computed in that time)? G can be checked in linear time Satisfiabilit of can be checked in constant time No, this does not mean that ou can solve SA in constant time

9 Bad News About BDDs he size of a BDD can be eponential in the number of boolean variables he sizes of the BDDs are ver sensitive to the variable ordering. Bad variable ordering can cause eponential increase in the size of the BDD here are functions which have BDDs that are eponential for an variable ordering (for eample binar multiplication) Pre condition (EX) computation requires a sequence of eistential variable eliminations A sequence of eistential variable eliminations can cause an eponential blow-up in the size of the BDD

10 BDDs are Sensitive to Variable Ordering Identit relation for two variables: ( ) (' ) Variable order:,,, ' Variable order:,,, ' or n variables, 3n+2 nodes or n variables, 3 2 n 1 nodes

11 BDDs from Another Perspective An Boolean formula f on variables 1, 2,, n can be written as (called Shannon epansion): f = i f [rue/ i ] i f [alse/ i ] (this is an if-then-else) BDDs use this idea his node corresponds to the formula alse, which comes from the Shannon epansion: alse [alse/] his node corresponds to the formula, which comes from the Shannon epansion: [rue/]

12 How to Implement BDDs? irst, let s pick a data structure for a BDD node: tpe verte = record low, high: verte; inde: 1.. n+1; val: {0, 1, X}; id: integer; end; High is the true branch, Low is the false branch Inde from the variable ordering, each inde value corresponds to one variable n is the number of Boolean variables 0 corresponds to false, 1 corresponds to true, X corresponds to no value his field will be used to generate a unique id for each unique function

13 How to Implement a BDD? A BDD is a rooted directed graph with verte set V containing two tpes of vertices nonterminal vertices: inde {1, 2,.., n} low(v) and high(v) are in V val(v) is X terminal vertices: inde(v) = n+1 val(v) is 0 or 1 low(v) and high(v) are null

14 BDD Reduce algorithm Start from the terminal nodes and go towards to root 1. Remove duplicate terminals: If two terminal vertices have the same value, remove one of them redirect all the incoming arcs to the other one 2. Remove duplicate non-terminals: If two nonterminal vertives, v and u have the same inde and v.low=u.low and v.high=u.high then eliminate one of them and redirect all incoming arcs to the other one 3. Remove redundant tests: If a nonterminal verte v has v.low=v.high then remove v and redirect all incoming arcs to low(v)

15 Reduce Algorithm function Reduce(v: verte): verte; var subgraph: arra[1.. G ] of verte; var vlist: arra[1.. n+1] of list of verte; begin Put each verte u reachable from v on list vlist[u.inde] netid := 0; for i := n+1 downto 1 do begin Q := empt set; for each u in vlist[i] do if u.inde = n+1 then add <ke,u> to Q where ke=(u.value) {terminal} else if u.low.id=u.high.id then u.id := u.low.id; {redundant verte} else add <ke,u> to Q where ke =(u.low.id,u.high.id);

16 Reduce Algorithm Continued Sort elements of Q b kes; oldke := (-1,-1); {unmatchable ke} for each <ke,u> in Q removed in order do if ke = oldke then u.id := netid; {matches eisting verte} else begin {unique verte} netid :=netid+1; u.id:=netid; subgraph[netid]:=u; u.low := subgraph[u.low.id]; u.high := subgraph[u.high.id]; oldke := ke; end; end; {end of the outmost for loop} return(subgraph[v.id]); end;

17 Reduce Algorithm Reduce algorithm can be done in linear time here is a linear time leicographic sorting method based on bucket sorting for sorting the vertices according to their kes Assuming a linear time sorting routine, processing at each level requires time proportional to the number of vertices at that level, and each level is processed once, resulting in linear time compleit

18 Appl Algorithm We can use the Shannon epansion to recursivel compute an binar Boolean operation Given BDDs for f and g and binar operation op f op g = i (f [/ i ] op g [/ i ]) i (f [/ i ] op g [/ i ]) So the idea is to start at the root of f and g and recursivel call true and false branches Ke idea: Use memoization!

19 Appl Algorithm var : arra[1.. G1, 1.. G2 ] of verte; {init. to null} function Appl(v1, v2: verte; <op> operator): verte; begin u := [v1.id, v2.id]; if u!= null then return(u); {alread computed} u := new verte; [v1.id, v2.id] := u; u.value := v1.value <op> v2.value; if u.value!= X then u.inde := n+1; u.low :=null; u.high :=null; {terminal} else begin {nonterminal} u.inde := Min(v1.inde, v2.inde); if v1.inde = u.inde then vlow1 := v1.low; vhigh1 := v1.high; else vlow1 := v1; vhigh1 := v1; if v2.inde = u.inde then vlow2 := v2.low; vhigh2 :=v2.high; else vlow2 := v2; vhigh2 := v2; u.low := Appl(vlow1, vlow2); u.high := Appl(vhigh1, vhigh2); end; return(u); end;

20 Appl Algorithm Given two input BDDs f and g the size of the resulting BDD for f <op> g is f g and it can be computed in that time he important point is to use memoization so that for an pair of vertices (one from each input BDD) the computation is done eactl once Since there are at most f g pairs the compleit is f g We do constant amount of work for each pair of nodes