HOCHIMINH CITY UNIVERSITY OF TECHNOLOGY

FACULTY OF ELECTRICAL & ELECTRONICS ENGINEERING

ELECTRONICS DEPARTMENT

Binary Decision Diagram (BDD)

 Motivation: Boolean Function Representation

 Boolean functions are mostly represented by truth tables and propositional formulas
�)
𝒇𝒇 𝒙𝒙, 𝒚𝒚 ≝ 𝒙𝒙(𝒚𝒚 + 𝒙𝒙
 Representation with truth table:
o Space inefficient. 100 variables results in 2100 lines.
o Checking satisfiability and equivalence is also inefficient.
Representation with propositional formula:
o Better than truth table in terms of compact representation.
o Deciding whether two prop. formulas f and g denote same Boolean function is expensive.
 Representing Switching Functions

 Truth Tables
• Satisfiability and equivalence check: easy; Boolean operations also easy.
• Very space inefficient: 2n entries for n variables.

 Disjunctive Normal Form (DNF) (SOP)

• Satisfiability is easy: find a disjunct without complementary literals.
• Negation and conjunction complicated.

 Conjunctive Normal Form (CNF) (POS)

• Satisfiability problem is NP-complete (Cook's theorem).
• Negation and disjunction complicated.
Representing Switching Functions
 Boolean Logic Functions Representations
Function can be represented in different ways
• Truth table, equation, K-map, circuit, etc. …
• Some representations not unique (not canonical)
 Binary Decision Diagrams - Why BDDs
An Efficient Representation

Synthesis, optimization, verification, and testing algorithms/tools manipulate large

Boolean functions
• Important to have efficient way to represent these functions
• Binary Decision Diagrams (BDDs) have emerged as a popular choice for
representing these functions

BDDs
• Graph representation similar to a binary tree
with terminal nodes labeled with either 0 or
1 and non-terminal nodes labeled with
Boolean variables x, y, z…
• Able to efficiently represent large functions
• Some representations are canonical (unique) Each non-terminal node has two edges
• One dashed line and one solid line
• Solid line: Corresponds when variable value = 1
• Dashed line: Corresponds when variable value = 0
 Mux Representation of Boolean Functions
MUX circuit to implement logic function S
 Mux Representation of Boolean Functions
Corresponding BDD to implement function S
One-to-one correspondence to the MUX gates in the flipped circuit

Same circuit Corresponding

just flipped BDD
 Binary Decision Diagram (BDD)
Example 1

How does it work?

• Line with bubble represent value = 0
• Lines without bubble represent value = 1
 Binary Decision Diagram (BDD)
Edge Notation

Several ways to represent value = 1 and value = 0

• Bubble vs. Non-bubble line
• Dashed vs. Solid line
• T (then) vs. E (else) labels
Truth Table, SoP, and PoS
x1 x2 x3 F
0 0 0 0
• Sum-of-products
0 0 1 0
F = x1’x2x3 + x1x2’x3 + x1x2x3
0 1 0 0
0 1 1 1
• Product-of-sums
1 0 0 0 F = (x1+x2+x3) & (x1+x2+x3’) & (x1+x2’+x3)
1 0 1 1 & (x1’+x2+x3) & (x1’+x2’+x3)
1 1 0 0
1 1 1 1
Truth Table and Decision Tree

x1 0 0 0 0 1 1 1 1
x2 0 0 1 1 0 0 1 1
x3 0 1 0 1 0 1 0 1 x1
0 1
F 0 0 0 1 0 1 0 1
x2 x2
0 1 0 1

x3 x3 x3 x3
0 1 0 10 1 0 1
0 0 0 1 0 1 0 1

October 31, 2023 12

Reduction of Decision Tree

Rule 1: Merging Rule: Rule 2: Elimination Rule:

Nodes must be unique Redundant tests should
not be present

a a a a

b b
b b b b

October 31, 2023 13

Example of Decision Tree Reduction
x1 x1 x1

x2 x2 x2 x2
x2

x3 x3 x3 x3 x3 x3 x3

0 0 0 1 0 1 0 1 0 1 0 1

Decision Tree
reduction BDD

14
BDD Formal Definition
• Directed Acyclic Graph (DAG)
o vertex set V
o edge set E (each edge has a head and tail => a direction)
o no cycles exist in G(V,E)
• Binary Decision Diagram (BDD)
o tree or rooted DAG where each vertex denotes a binary decision
o Example: F = (a + b)c
Representation of Boolean Functions - BDD

Ex : (a + b)(c + d)
Ex : ab + cd
a 1 a
0
0 b 1
0
b 1
c
1 1 c
0 0
0 d
0 1 d 0
0 1

0 1 0 1
BDD Formation – Steps for f = ab + cd

STEP 1 STEP 2 STEP 3 FINAL

VARIABLE a < b < c < d

ORDER

a a a a
1 1 1 1
0 0 0 0
b b b b
0 0 0
c c c c
1 1
1 1 1
d d
0 0 0
1

1 0 1 0 1
How to construct BDD?
f = ac + bc + a’b’c’
= a’ (b’c’ + bc) + a (c + bc)
= a’ (b’c’ + bc) + a (c) This is the
f first step.
The process
a is continued
for all input
variables.

b’c’ + bc c
BDD Reduction Rules
Cofactor and Boolean expansion
Example
BDD Synthesis
 Binary Decision Diagram (BDD)
Example 2

Let’s consider another function

f(a,b,c,d) = abc + b’d + c’d
 Ordered Binary Decision Diagram (OBDD)
What is a OBDD?

Ordered binary decision diagrams ensure the variables appear in the same order along all paths
from the root to the leaves
 Ordered Binary Decision Diagram (OBDD)
Different Ordering Lead to Different Complexity – Example 1

Variable ordering important, may result in a more complex (or simple) BDD
• All three BDDs below represent the same function
• Third ordering (b ≤ c ≤ a ≤ d) optimal because there is exactly one node for each variable
 Ordered Binary Decision Diagram (OBDD)
Different Ordering Lead to Different Complexity – Example 2

• Consider F = ab + cd + ef, again both BDDs represent same function

• Variable order has a large impact on resulting BDD, first variable ordering (a ≤ b ≤ c ≤ d
≤ e ≤ f) yields a much simpler BDD
ROBDD
Ordered BDD (OBDD) Input variables are ordered - each path from root to sink
visits nodes with labels (variables) in ascending order.

ordered not
a a
order = a,c,b ordered
c c b c

b c b

0 1 0 1

Reduced Ordered BDD (ROBDD) - reduction rules:

1. if the two children of a node are the same, the node is eliminated: f
= vf + vf
2. two nodes have isomorphic graphs => replace by one of them
These two rules make it so that each node represents a distinct logic
function.
27
ROBDD – Example 1
root
node f = ab+a’c+bc’d a
a
1

c+bd b c+bd c
b b

c+d 0
c c c d+b d

d b b
d

0 1 0 1

Two different orderings, same function.

28
ROBDD – Example 2
• f = (a + b).c

OBDD for order OBDD for order ROBDD for order

(a,c,b) (a,b,c) (a,b,c)

29
ROBDD – Example 3

30
ROBDD – Practice 1
f = abc + bd + cd

b b
0 1 0 1

cd ac + d + cd c c
0 0 1
b
0 1 0 d d
0 1 0
c c 1
0 1 0 0 1 a 1
1
0 1
0 d d a+d
0 1

31
ROBDD – Practice 2
f = abc + b’d + c’d

32
ROBDD – Practice 3

33
 An Important Point

• The size of a BDD can vary drastically if the order in which the
variables are expanded is changed.
• The number of nodes in the BDD can be exponential in the number
of variables in the worst case, even after reduction.
 Some Benefits of BDD

• Check for tautology is trivial.

– BDD is a constant 1.
• Complementation.
– Given a BDD for a function f, the BDD for f’ can be obtained by
interchanging the terminal nodes.
• Equivalence check.
– Two functions f and g are equivalent if their BDDs (under the same variable
ordering) are the same.
Tautology Checking
 BDD Derivatives
• MDD: Multi-valued BDDs
• natural extension, have more then two branches
• can be implemented using a regular BDD package with binary encoding
• advantage that binary BDD variables for one MV variable do not have to stay together -> potentially better
ordering
• ADDs: (Analog BDDs) MTBDDs
• multi-terminal BDDs
• decision tree is binary
• multiple leafs, including real numbers, sets or arbitrary objects
• efficient for matrix computations and other non-integer applications
• FDDs: Free BDDs
• variable ordering differs
• not canonical anymore

• and many more …..

37
Zero Suppressed BDDs - ZBDDs
ZBDD’s were invented by Minato to efficiently represent sparse sets. They have
turned out to be useful in implicit methods for representing primes (which
usually are a sparse subset of all cubes).

Different reduction rules:

• BDD: eliminate all nodes where then edge and else edge point to the same
node.
• ZBDD: eliminate all nodes where the then node points to 0. Connect incoming
edges to else node.
• For both: share equivalent nodes.

ZBDD:
BDD: 0 1
0
1
0
0 1 0 1
0 1 0 1
38
Canonicity
Theorem: (Minato) ZBDD’s are canonical given a variable ordering and the support set.

x1 x3 x3
Example:
x1
x2
x2 1
1 0 1
BDD ZBDD if 1 0 ZBDD if
support is support is
x 1, x 2 x 1, x 2, x 3

x3

x1
x2
1
1 0 ZBDD if
BDD support is
x 1, x 2 , x 3
39
 Zero-Suppressed BDDs

Rule 1: Elimination Rule: Rule 2: Elimination Rule:

Redundant tests should Remove nodes with 1-edge
not be present pointing to 0-terminal

a a

b b b
b
0

October 31, 2023 40

 Complement Edges
• BDD edges can carry attributes
• Using complementation as an attribute for edges
saves BDD nodes and makes NOT a constant time
operation
• To maintain canonicity, the use of attribute edges
should be constrained

October 31, 2023 41

 Equivalent Pairs of Functions

x x x x

x x x x

October 31, 2023 42

 An Important Point

• The size of a BDD can vary drastically if the order in which the variables
are expanded is changed.
• The number of nodes in the BDD can be exponential in the number of
variables in the worst case, even after reduction.
 Use of BDD in Synthesis
• BDD is canonical for a given variable ordering.
• It implicitly uses factored representation:
x
x’h + xh = h
h y h y

a b a b

h x h x h x

y z y z y z

ah + bh = (a+b)h
• Variable reordering can reduce the size of BDD.
• Implicit logic minimization.
• Some redundancy rumored during the construction of
BDD itself.
MUX realization of functions

f f

x 0 1 x

f g

f g
MUX-based Functional Decomposition

f f

0 1
h

g
h
f g f

An example ===>
MUX-based Functional Decomposition’s Example

f f

a
0 1

b a
c d
c b

0 1
0 1
Synthesis Example

49
Synthesis Example (g)

50
Synthesis Example (h)

51
Synthesis Example (share)
Efficient Implementation of BDD’s
Unique Table:
• avoids duplication of existing nodes
– Hash-Table: hash-function(key) = value
– identical to the use of a hash-table in AND/INVERTER circuits

hash value collision

of key chain

Computed Table:
• avoids re-computation of existing results

hash value
No collision chain
of key

53
Efficient Implementation of BDD’s
• BDDs is a compressed Shannon co-factoring tree:
• f = v fv + v fv
• leafs are constants “0” and “1”
• Three components make ROBDDs canonical (Proof: Bryant 1986):
– unique nodes for constant “0” and “1”
– identical order of case splitting variables along each paths
– hash table that ensures:
• (node(fv) = node(gv)) ∧ (node(fv) = node(gv)) ⇒ node(f) = node(g)
– provides recursive argument that node(f) is unique when using the
unique hash-table
f
v
0 1

fv fv
54
 Onset is Given by all Paths to “1”
F = b’+a’c’ = ab’+a’cb’+a’c’ all paths to the 1 node
a f
0
fa = cb’+c’ 1
c 1 fa= b’
0 b
0
1
0 1
Notes:
• By tracing paths to the 1 node, we get a cover of pair wise disjoint cubes.
• The power of the BDD representation is that it does not explicitly
enumerate all paths; rather it represents paths by a graph whose size is
measures by its nodes and not paths.
• A DAG can represent an exponential number of paths with a linear
number of nodes.
• BDDs can be used to efficiently represent sets
– interpret elements of the onset as elements of the set
– f is called the characteristic function of that set
55
Implementation
Variables are totally ordered: If v < w then v occurs “higher” up in the ROBDD
Top variable of a function f is a variable associated with its root node.
Example: f = ab + a’bc + a’bc’. Order is (a < b < c).
fa = b, fa = b
f b is top variable of f
a
b f
f does not depend on a, b reduced
since fa = fa .
0 1 0 1

Each node is written as a triple: f = (v,g,h) where g = fv and h = fv .

We read this triple as:
f = if v then g else h = ite (v,g,h) = vg+v ’ h
f v is top variable of f
f v
v 1 0 mux 0 1

g h g
h
56
ITE Operator
ite(f , g , h=
) fg + f h
ITE operator can implement any two variable logic function. There are 16 such
functions corresponding to all subsets of vertices of B 2:
Table Subset Expression Equivalent Form
0000 0 0 0
0001 AND(f, g) fg ite(f, g, 0)
0010 f>g fg ite(f,g, 0)
0011 f f f
0100 f<g fg ite(f, 0, g)
0101 g g g
0110 XOR(f, g) f⊕g ite(f,g, g)
0111 OR(f, g) f+g ite(f, 1, g)
1000 NOR(f, g) f+g ite(f, 0,g)
1001 XNOR(f, g) f⊕g ite(f, g,g)
1010 NOT(g) g ite(g, 0, 1)
1011 f≥g f + g ite(f, 1, g)
1100 NOT(f) f ite(f, 0, 1)
1101 f≤g f + g ite(f, g, 1)
1110 NAND(f, g) fg ite(f, g, 1)
1111 1 1 1

57
Unique Table - Hash Table
hash index collision
of key chain

• Before a node (v, g, h ) is added to BDD data base, it is looked up in

the “unique-table”. If it is there, then existing pointer to node is used to
represent the logic function. Otherwise, a new node is added to the
unique-table and the new pointer returned.
• Thus a strong canonical form is maintained. The node for f = (v, g, h )
exists iff(v, g, h ) is in the unique-table. There is only one pointer for (v,
g, h ) and that is the address to the unique-table entry.
• Unique-table allows single multi-rooted DAG to represent all users’
functions:

58
Recursive Formulation of ITE

v = top-most variable among the three BDDs f, g, h

Where A, B are pointers to results of ite(fv,gv,hv) and ite(fv’,gv’,hv’})

- merged if equal
59
Recursive Formulation of ITE
Algorithm ITE(f, g, h)
if(f == 1) return g
if(f == 0) return h
if(g == h) return g

if((p = HASH_LOOKUP_COMPUTED_TABLE(f,g,h)) return p

v = TOP_VARIABLE(f, g, h ) // top variable from f,g,h
fn = ITE(fv,gv,hv) // recursive calls
gn = ITE(fv,gv,hv)
if(fn == gn) return gn // reduction
if(!(p = HASH_LOOKUP_UNIQUE_TABLE(v,fn,gn)) {
p = CREATE_NODE(v,fn,gn) // and insert into UNIQUE_TABLE
}
INSERT_COMPUTED_TABLE(p,HASH_KEY{f,g,h})
return p
}

60
 Example
F G H I
a a b a
1 0 1 0 1 0 1 0
B D C J
b C c d b
1 0 1
1 0 1 0 1 0 1 0
D
1 0 1 0 1 0 0

I = ite (F, G, H) F,G,H,I,J,B,C,D

= (a, ite (Fa , Ga , Ha ), ite (Fa , Ga , Ha )) are pointers

= (a, ite (1, C , H ), ite(B, 0, H ))

= (a, C, (b , ite (Bb , 0b , Hb ), ite (Bb , 0b , Hb ))
= (a, C, (b , ite (1, 0, 1), ite (0, 0, D)))
= (a, C, (b , 0, D))
= (a, C, J)

Check: F = a + b, G = ac, H = b + d
ite(F, G, H) = (a + b)(ac) + ab(b + d) = ac + abd
61
Computed Table
Keep a record of (F, G, H ) triplets already computed by the ITE operator
– software cache ( “cache” table)
– simply hash-table without collision chain (lossy cache)

62
Extension - Complement Edges
Combine inverted functions by using complemented edge
– similar to circuit case
– reduces memory requirements
– BUT MORE IMPORTANT:
• makes some operations more efficient (NOT, ITE)
G G

two different
DAGs

0 1 0 1

G G
only one DAG
using complement
pointer

63
0 1
Extension - Complement Edges

To maintain strong canonical form, need to resolve 4 equivalences:

V V V V

V V V V

Solution: Always choose one on left, i.e. the “then” leg must have no
complement edge.

64
 Ambiguities in Computed Table
Standard Triples: ite(F, F, G ) ⇒ ite(F, 1, G )
ite(F, G, F ) ⇒ ite(F, G, 0 )
ite(F, G,F ) ⇒ ite(F, G, 1 )
ite(F,F, G ) ⇒ ite(F, 0, G )

To resolve equivalences: ite(F, 1, G ) ≡ ite(G, 1, F )

ite(F, 0, G ) ≡ ite(G, 1,F )
ite(F, G, 0 ) ≡ ite(G, F, 0 )
ite(F, G, 1 ) ≡ ite(G,F, 1 )
ite(F, G,G ) ≡ ite(G, F,F )

To maximize matches on computed table:

1. First argument is chosen with smallest top variable.
2. Break ties with smallest address pointer. (breaks PORTABILITY!!!!!!!!!!)
Triples:
ite(F, G, H ) ≡ ite (F, H, G ) ≡ ite (F, G,H) ≡ ite (F, H, G)
Choose the one such that the first and second argument of ite should not be
complement edges(i.e. the first one above).
65
Use of Computed Table
• Often BDD packaged use optimized implementations for special operations
– e.g. ITE_Constant (check whether the result would be a constant)
– AND_Exist (AND operation with existential quantification)

• All operations need a cache for decent performance

– local cache
• for one operation only - cache will be thrown away after operation is finished (e.g.
AND_Exist
• keep inter-operational (ITE, …)
– special cache for each operation
• does not need to store operation type
– shared cache for all operations
• better memory handling
• needs to store operation type

66
Example: Tautology Checking
Algorithm ITE_CONSTANT(f,g,h) { // returns 0,1, or NC
if(TRIVIAL_CASE(f,g,h) return result (0,1, or NC)
if((res = HASH_LOOKUP_COMPUTED_TABLE(f,g,h))) return res
v = TOP_VARIABLE(f,g,h)
i = ITE_CONSTANT(fv,gv,hv)
if(i == NC) {
INSERT_COMPUTED_TABLE(NC, HASH_KEY{f,g,h}) // special table!!
return NC
}
e = ITE_CONSTANT(fv,gv,hv)
if(e == NC) {
INSERT_COMPUTED_TABLE(NC, HASH_KEY{f,g,h})
return NC
}
if(e != i) {
INSERT_COMPUTED_TABLE(NC, HASH_KEY{f,g,h})
return NC
}
INSERT_COMPUTED_TABLE(e, HASH_KEY{f,g,h})
return i;
}
67
 Compose
Compose(F, v, G ) : F(v, x) → F( G(x), x), means substitute v by G(x)
Algorithm COMPOSE(F,v,G) {
if(TOP_VARIABLE(F) > v) return F // F does not depend
on v
if(TOP_VARIABLE(F) == v) return ITE(G,F1,F0)
i = COMPOSE(F1,v,G)
e = COMPOSE(F0,v,G)
return ITE(TOP_VARIABLE(F),i,e) // Why not
CREATE_NODE...
}
Notes:
1. F1 is the 1-child of F, F0 the 0-child.
2. G , i, e are not functions of v
3. If TOP_VARIABLE of F is v, then ite (G , i, e ) does replacement of
v by G.

68
Variable Ordering
• Static variable ordering
– variable ordering is computed up-front based on the problem structure
– works very well for many combinational functions that come from circuits we actually build
• general scheme: control variables first
• DFS order is pretty good for most cases
– work bad for unstructured problems
• e.g., using BDDs to represent arbitrary sets
– lots of research in ordering algorithms
• simulated annealing, genetic algorithms
• give better results but extremely costly

69
Dynamic Variable Ordering
• Changes the order in the middle of BDD applications
– must keep same global order

• Problem: External pointers reference internal nodes!!!

External reference pointers attached

to application data structures

BDD Implementation:
... ...
... ...

70
Dynamic Variable Ordering
Theorem (Friedman):
Permuting any top part of the variable order has no effect on the nodes labeled by variables in
the bottom part.
Permuting any bottom part of the variable order has no effect on the nodes labeled by variables
in the top part.

• Trick: Two adjacent variable layers can be exchanged by keeping the original memory locations
for the nodes
mem1
f0 f f1 f0 f f1
mem1
mem2
a mem2 mem3 b b b
mem3
b b a a

c c c c c c c c
f00 f01 f10 f11 f00 f01 f10 f11
71
Dynamic Variable Ordering
• BDD sifting:
– shift each BDD variable to the top and then to the bottom and see which position had minimal
number of BDD nodes
– efficient if separate hash-table for each variable
– can stop if lower bound on size is worse then the best found so far
– shortcut:
• two layers can be swapped very cheaply if there is no interaction between them
– expensive operation, sophisticated trigger condition to invoke it

• grouping of BDD variables:

– for many applications, pairing or grouping variables gives better ordering
• e.g. current state and next state variables in state traversal
– grouping them for sifting explores ordering that are otherwise skipped

72
Garbage Collection
• Very important to free and ruse memory of unused BDD nodes
– explicitly freed by an external bdd_free operation
– BDD nodes that were temporary created during BDD operations

• Two mechanism to check whether a BDD is not referenced:

– Reference counter at each node
• increment whenever node gets one more reference (incl. External)
• decrement when node gets de-references (bdd_free from external, de-
reference from internal)
• counter-overflow -> freeze node
– Mark and Sweep algorithm
• does not need counter
• first pass, mark all BDDs that are referenced
• second pass, free the BDDs that are not marked
• need additional handle layer for external references

73
Garbage Collection
• Timing is very crucial because garbage collection is expensive
– immediately when node gets freed
• bad because dead nodes get often reincarnated in next operation
– regular garbage collections based on statistics collected during BDD operations
– “death row” for nodes to keep them around for a bit longer

• Computed table must be cleared since not used in reference mechanism

• Improving memory locality and therefore cache behavior:

– sort freed BDD nodes

74