Binary Decision Diagrams��
��v0
��
��v1
��
��v2
��
��v3
��
��v4
T F
��
��
���/
?
��
���+
?
?
SSSw
SSSw
��
���+ ?
BBBBBBBN
1 0
1
01
0
0
0
1
1
{{v0, v1, v4}, {v0, v1, v2, v3, v4}, {v0, v1, v2, v3}, {v0, v2, v3, v4}, {v1, v2, v3}}
Rooted binary directed acyclic graphTwo leaves labeled T and FOther nodes are labeled with variable namesEdges are labeled 0 or 1Out of each non-leaf, one edge is labeled 0
and one edge is labeled 1There is an order on the variables of the BDD
and variables on any path obey itA single BDD compactly represents a Boolean
function
Binary Decision Diagrams��
��v0
��
��v1
��
��v2
��
��v3
��
��v4
T F
��
��
���/
?
��
���+
?
?
SSSw
SSSw
��
���+ ?
BBBBBBBN
1 0
1
01
0
0
0
1
1
{{v0, v1, v4}, {v0, v1, v2, v3, v4}, {v0, v1, v2, v3}, {v0, v2, v3, v4}, {v1, v2, v3}}
v0 v1 v2 v3 v4 f
0 0 0 0 0 0
0 0 0 0 1 1
0 0 0 1 0 0
0 0 0 1 1 1
0 0 1 0 0 0
0 0 1 0 1 1
0 0 1 1 0 0
0 0 1 1 1 1
0 1 0 0 0 1
0 1 0 0 1 1
0 1 0 1 0 1
0 1 0 1 1 1
0 1 1 0 0 0
0 1 1 0 1 1
0 1 1 1 0 0
0 1 1 1 1 0
1 0 0 0 0 1
1 0 0 0 1 1
1 0 0 1 0 1
1 0 0 1 1 1
1 0 1 0 0 0
1 0 1 0 1 1
1 0 1 1 0 0
1 0 1 1 1 0
1 1 0 0 0 1
1 1 0 0 1 1
1 1 0 1 0 1
1 1 0 1 1 1
1 1 1 0 0 0
1 1 1 0 1 1
1 1 1 1 0 0
1 1 1 1 1 0
Binary Decision Diagrams��
��v0
��
��v1
��
��v2
��
��v3
��
��v4
T F
��
��
���/
?
��
���+
?
?
SSSw
SSSw
��
���+ ?
BBBBBBBN
1 0
1
01
0
0
0
1
1
{{v0, v1, v4}, {v0, v1, v2, v3, v4}, {v0, v1, v2, v3}, {v0, v2, v3, v4}, {v0, v2, v3}}
Rooted binary directed acyclic graphTwo leaves labeled T and FOther nodes are labeled with variable namesEdges are labeled 0 or 1Out of each non-leaf, one edge is labeled 0
and one edge is labeled 1There is an order on the variables of the BDD
and variables on any path obey itA single BDD compactly represents a Boolean
functionEvery path to F represents a clause, anding
them gives the function
Binary Decision Diagrams
{{v0, v1, v2, v3, v4}, {v0, v1, v2, v3, v4}, . . . , {v0, v1, v2, v3, v4}, . . . , {v0, v1, v2, v3, v4}}
Binary Decision Diagrams��
��v0
��
��v1
��
��v2
��
��v3
��
��v4
T F
��
��
���/
?
��
���+
?
?
SSSw
SSSw
��
���+ ?
BBBBBBBN
1 0
1
01
0
0
0
1
1
ite(v0,
ite(v2,
ite(v3,F,ite(v4,T,F))
T)
ite(v1,
ite(v2,
ite(v3,F,ite(v4,T,0))
T)
ite(v4,T,F)))
order(v4, v3, v2, v1, v0)
ite(v4,T,F) ; BDD $1 Created
ite(v3,F,$1) ; BDD $2 Created
ite(v2,$2,T) ; bdd $3 created
ite(v1,$3,$1) ; bdd $4 created
ite(v0,$3,$4) ; bdd $5 created
print($5)
Binary Decision Diagrams
Via the BDD-visualizer - ordering affects size
Binary Decision Diagrams
order(v4, v3, v2, v1, v0)
ite(v4,T,F) ; BDD $1 Created
ite(v3,F,T) ; BDD $2 Created
ite(v2,$2,T) ; bdd $3 created
ite(v1,$2,$1) ; bdd $4 created
print($3,$4)
findOrCreateNode(v,t,e) {if (t == e) return t;
if ((node = lookup(<v,t,e>)) != null)
return node;
node = createNode(<v,t,e>);
insertNodeDataBase(<v,t,e>,node)
return node;
}
Hashtable lookup on nodes - nodes shared across BDDs
Binary Decision Diagrams
order(v4, v3, v2, v1, v0)
ite(v4,T,F) ; BDD $1 Created
ite(v3,F,T) ; BDD $2 Created
ite(v2,$2,T) ; bdd $3 created
ite(v1,$2,$1) ; bdd $4 created
and(3,4) ; bdd $5 created
print($5)
All interesting applications conjoin BDDs
Binary Decision Diagrams
Conjoining is a bottom up process - complexity linear in # nodes
Binary Decision Diagrams
Conjoining is a bottom up process - complexity linear in # nodes
Binary Decision Diagrams
Conjoining is a bottom up process - complexity linear in # nodes
Binary Decision Diagrams
Conjoining is a bottom up process - complexity linear in # nodesbut the number of nodes can double - hence 2n nodes may resultfrom n binary conjunctions.
Binary Decision Diagrams
Conjoining is a bottom up process - complexity linear in # nodesbut the number of nodes can double - hence 2n nodes may resultfrom n binary conjunctions. But more conjunctions may reducethe size of the BDD - here not(or(v2,v4)) is added.
Binary Decision Diagrams
Conjoining is a bottom up process - complexity linear in # nodesbut the number of nodes can double - hence 2n nodes may resultfrom n binary conjunctions. But more conjunctions may reducethe size of the BDD - here not(or(v2,v4)) is added. Then or(v2,v3)
Binary Decision Diagrams
Can something be done to prevent an exponential blowup?Existential quantification:
A Boolean function which can be written
f(v, ~x) = (v ∧ h1(~x)) ∨ (¬v ∧ h2(~x))
can be replaced by
f(~x) = h1(~x) ∨ h2(~x)
where ~x is a list of one or more variables.
There is a solution to f(~x) if and only if there is a solution tof(v, ~x) so it is sufficient to solve f(~x) to get a solution to f(v, ~x).
- a variable is eliminated!- this is natural for BDDs
Binary Decision Diagrams
exQuant (f, v)/* Input: BDD f , variable v *//* Output: BDD f with v existentially quantified away */
If root(f) == v then Return then(root(f))∨else(root(f)).If index(v) > index(root(f)) then Return 0. // If v is not in f do nothingSet hf1
← exQuant(then(root(f)), v).Let hf0
← exQuant(else(root(f)), v).If hf0
== hf1then Return hf1
.Return findOrCreateNode(root(f), hf1
, hf0).
where index(vi) == i.restriction: v must only be in f .
Binary Decision Diagrams��
� v1
��
� v2
��
� v2
��
� v3
��
� v3
F T
T⇒v3
��/
SSw
��/
QQs
�������
�
��/
@@R
���������)
��
��+
0 1
01 1
0
0 1 10
��
� v1
��
� v2
��
� v3
F T
��
� v1
T F
⇒v2
AAAU
����
?
HHHHj
?
��
�� @@R
01
0
11 0
1 0
Existentially quantifying away a variable can win big
infer v1 = T
eliminate BDD
Binary Decision Diagrams
0
v8
T
1 0
v7
1
v5
1 0
1
v4
1 0
0
v6
T F T F
v2
1 0
1
v1
1 0
0
v3
T F T F
But it can blur functional relationships -This BDD separates v1. v2, v3 from v4, v5, v6 if v7 is chosen during searchWithout ExQu, v8 = 0, v7 = 1, v6 = 1 reveals the inference v5 = 1.
Binary Decision Diagrams
1 0
T
v8
v6
1 0
v5
T
v2
1 0
1
v1
1 0
0
v3
T F T F
1 0
v4
T
v2
1 0
1
v1
1 0
0
v3
T F T F
1 0
But it can blur functional relationships -With ExQu must also have v2 = 0 and v1 = 0 to get the same inference.
Binary Decision DiagramsConsider the truth tables for BDDs f and c.
Build a new BDD g over variables in f and c.
On row of c’s truth table that has value 1,let the corresponding row in g map to the same value as f map to.
On other rows g maps to any value, independent of f .
Observe f ∧ c and g ∧ c are identical,so g can replace f in a collection of BDDs.
BDD g is said to be a reduction - there are several types
1. BDD g can be made smaller than f .
2. Inferences can be discovered.
3. BDDs can be removed from the collection without loss.
Binary Decision DiagramsObvious reduction: g maps to 0 all rows that c maps to 0.
Called zero-restrict, has weaknesses - for example
c = (v1 ∨ ¬v2) ∧ (¬v1 ∨ ¬v3)
f = (v2 ∨ ¬v3)
will yield
g = ¬v3 ∧ (v1 ∨ (¬v1 ∧ ¬v2))
instead of the possible
g = (¬v3)
Obvious dual: g maps to 1 all rows that c maps to 0
No better.
Desired: some rows of g to map to 1, others to 0 so that
g’s truth table reflects a logic pattern that generates inferences.
g maps 〈011〉 and 〈111〉 to 0 and 〈010〉 and 〈101〉 to 1 to get ¬v3.
Binary Decision Diagrams
Example:
f = (v1 ∨ ¬v2 ∨ v3) ∧ (¬v1 ∨ v2) and
c = (v1 ∨ ¬v2)
Let g have the same truth table as f except for row 〈011〉 which c maps
to 0 and g maps to 1.
Then g = (v1 ↔ v2) and f ∧ c is the same as g ∧ c but g is smaller than f .
Binary Decision Diagrams
The two BDDs on the right replace the two on the left
Binary Decision Diagrams
Use the symbol ⇓ to denote the restrict operator.
Then g = f ⇓ c or restrict(f ,c) is the result of
zero-restrict after all variables in c that are not in f
are existentially quantified away from c.
Binary Decision Diagrams
restrict (f, c)/* Input: BDD f , BDD c *//* Output: BDD f restricted by c */
If c or f is terminal(T ) or if f is terminal(F ) return f .If c == ¬f return terminal(F ).If c == f return terminal(T ).// f and c have a non-trivial relationshipSet vf ← root(f). // vf is a variableSet vc ← root(c). // vc is a variableIf index(vf ) > index(vc) return restrict(f , exQuant(c, vc)).If reduce0(vf , c) is terminal(F ) then
Return restrict(reduce1(vf , f), reduce1(vf , c)).If reduce1(vf , c) is terminal(F ) then
Return restrict(reduce0(vf , f), reduce0(vf , c)).Set hf1
← restrict(reduce1(vf , f), reduce1(vf , c)).Set hf0
← restrict(reduce0(vf , f), reduce0(vf , c)).If hf1
== hf0then Return hf1
.Return findOrCreateNode(vf , hf1
, hf0).
Binary Decision Diagrams
Example:
f = (v1 → v2) ∧ (¬v1 → (¬v3 ∧ v4)) and
c = (v1 ∨ v3).
Let g have the same truth table as f except g maps rows
〈0001〉 and 〈0101〉 to 0, as does c.
Then g = (v1) ∧ (v2), and two inferences are revealed.
Binary Decision Diagrams
��
� v1
��
� v3
��
� v2
��
� v4
T F
���/
SSSw
���/
?
��
��
��
���+
��
�/@
@R
0 1
10
01
1 0
��
� v1
��
� v3
T F?
SSSw
��/
SSw
1
0
1 0⇓
f = (v1 → v2) ∧ (¬v1 → (¬v3 ∧ v4))
c = (v1 ∨ v3) g = (v1) ∧ (v2)
��
� v1
��
� v2
T F?
���/
��/
SSw
1
01 0
⇒
A call to restrict(f ,c) returns g and two inferences
Binary Decision Diagrams
��
� v1
��
� v3
��
� v2
T F
���/
SSSw
?Q
QQQs ?
��
��+
1 0
01 0
1
��
� v2
��
� v3
T F
?
SSSw
���/
SSSw
1
0
0 1⇓
f = (v1 ∨ ¬v2) ∧ (¬v1 ∨ ¬v3) c = (v2 ∨ ¬v3)
⇒
��
� v1
��
� v3
��
� v2
T F
���/
SSSw
?Q
QQQs ?
��
��+
1 0
01 0
1
A call to restrict(f, c) results in no change.
Binary Decision Diagrams
��
� v1
��
� v3
��
� v2
T F
���/
SSSw
?Q
QQQs ?
��
��+
1 0
01 0
1
��
� v2
��
� v3
T F
?
SSSw
���/
SSSw
1
0
0 1 ⇓
c = (v1 ∨ ¬v2) ∧ (¬v1 ∨ ¬v3)f = (v2 ∨ ¬v3) g = (¬v3)
⇒
��
� v3
T F
���/
SSSw
0 1
But reversing the roles of f and c results in the inference g = ¬v3
Binary Decision Diagrams
��
� v1
��
� v3
��
� v2
T F
SSSw
���/
ZZ
ZZ~?
��
��=?
01
10 0
1
��
� v1
��
� v3
T F
?
SSSw
���/
SSSw
0
1
1 0⇓
f = (v1 ∨ ¬v2) ∧ (¬v1 ∨ v3) c = (¬v1 ∨ v3) g = (v1 ∨ ¬v2)
��
� v1
��
� v2
F T
?
���/
���/
SSSw
0
11 0
⇒
restrict(f, c) spreads an inference evident in one BDD over multiple BDDs.
If v3 is assigned 0 in f then v1 = 0 and v2 = 0 are inferred.
After replacing f with g = restrict(f, c), to get the inference v2 = 0 from
the choice v3 = 0, visit c to get v1 = 0 and then g to get v2 = 0.
Thus, restrict can increase work if not used properly. In this case,
restricting in the reverse direction leads to a better result.
Binary Decision Diagrams
BDD g is a generalized co-factor of f and c if for any truth assignment t,
g(t) has the same value as f(t′) where t′ is the “nearest” truth
assignment to t that maps c to 1.
The notion of “nearest” truth assignment depends on a permutation π of
the numbers 1, 2, . . . , n which states the variable ordering of the input BDDs.
Represent a truth assignment to n variables as a vector in {0, 1}n
for assignment t, let ti denote the ith bit of the vector representing t.
Then the distance between two truth assignments t′ and t′′ is defined as∑n
i=12n−i(t′πi
⊕ t′′πi).
One pair of assignments is nearer to each other than another pair if
the distance between that pair is less.
Distances between pairs are unique for each pair.
Binary Decision Diagrams
gcf (f, c)/* Input: BDD f , BDD c *//* Output: greatest co-factor of f by c */
If f == terminal(F ) or c == terminal(F ) return terminal(F ).If c == terminal(T ) or f == terminal(T ) return f .Set vm ← index−1(min{index(root(c)), index(root(f))}).// vm is the top variable of f and c
If reduce0(vm, c) == terminal(F ) thenReturn gcf(reduce1(vm, f), reduce1(vm, c)).
If reduce1(vm, c) == terminal(F ) thenReturn gcf(reduce0(vc, f), reduce0(vc, c)).
Set h1 ← gcf(reduce1(vm, f), reduce1(vm, c)).Set h0 ← gcf(reduce0(vm, f), reduce0(vm, c)).If h1 == h0 then Return h1.Return FindOrCreateNode(vm, h1, h0).
Binary Decision Diagrams
�
�v1
�
�v2
�
�v3
T F
��/
SSw
? ?Q
QQQs
��
��+
1 0
01 1
0
�
�v2
�
�v3
T F?
SSw
SSw
��/
10
1 0
�
�v1
�
�v2
�
�v2
�
�v3
F T
��/
SSw
?
JJ
JJJ ?
SSw
��/
������
1 0
10
01
0
1
f = (v1 → ¬v2) ∨ (¬v1 → v3) c = (v2 ∨ v3)
gcf(f, c) = (v1 → ¬v2) ∨ (¬v1 → (v2 → v3))
With variable ordering is v1 < v2 < v3, gcf(f ,c) is more complicated
Binary Decision Diagrams
�
�v1
�
�v2
�
�v2
�
�v3
�
�v3
T F
��/
SSw
? ?
SSw
��/
��/
������SSw
HHHHHj
1 0
01
10
0
1
1
0
�
�v1
�
�v2
T F?
SSw
SSw
��/
10
1 0
�
�v1
�
�v2
�
�v3
F T
QQs
? ?
��/
��/
SSw
0
1
1
01 0
f = (v3 → ¬v2) ∨ (¬v3 → v1)
c = (v1 ∨ v2)
gcf(f, c) = (v1 ∧ (v2 → ¬v3))
Same variable ordering, v1 and v3 are swapped
Binary Decision Diagrams
Theorem:
Given BDDs f1, ..., fk, for any 1 ≤ i ≤ k, f1 ∧ f2 ∧ ... ∧ fk is satisfiable
if and only if (f1|fi) ∧ ... ∧ (fi−1|fi) ∧ (fi+1|fi) ∧ ... ∧ (fk|fi) is satisfiable.
Moreover, any assignment satisfying the latter can be mapped to an
assignment that satisfies f1 ∧ ... ∧ fk.
So generalized co-factoring can be used to eliminate one of the BDDs
among a given conjoined set of BDDs: the solver finds an assignment
satisfying gcf(f1, fi) ∧ ... ∧ gcf(fk, fi) and then extends the assignment
to satisfy fi, otherwise the solver reports that the instance has no solution.
Binary Decision Diagrams
Other properties:
1. f = c ∧ gcf(f, c) ∨ ¬c ∧ gcf(f,¬c).
2. gcf(gcf(f, g), c) = gcf(f, g ∧ c).
3. gcf(f ∧ g, c) = gcf(f, c)∧ gcf(g, c).
4. gcf(f ∧ c, c) = gcf(f, c).
5. gcf(f ∧ g, c) = gcf(f, c)∧ gcf(g, c).
6. gcf(f ∨ g, c) = gcf(f, c)∨ gcf(g, c).
7. gcf(f ∨ ¬c, c) = gcf(f, c).
8. gcf(¬f, c) = ¬ gcf(f, c).
9. If c and f have no variables in common and c is satisfiablethen gcf(f, c) = f .