Logic verification and synthesis using function graphs

PDF

Download

Open document

Flip pages

Download a page range

Download transcript

Copy asset link

Request this asset

Request accessible transcript

Transcript (if available)

Content Logic V erification and S y n th esis
u sin g F unction G raphs
by
Yung-Te Lai
A Dissertation Presented to the
FACULTY OF THE GRADUATE SCHOOL
UNIVERSITY OF SOUTHERN CALIFORNIA
In Partial Fulfillment of the
Requirements for the Degree
DOCTOR OF PHILOSOPHY
(Computer Engineering)
December 1993
Copyright 1993 Yung-Te Lai
UMI Number: DP22869
All rights reserved
INFORMATION TO ALL USERS
The quality of this reproduction is dependent upon the quality of the copy submitted.
In the unlikely event that the author did not send a complete manuscript
and there are missing pages, these will be noted. Also, if material had to be removed,
a note will indicate the deletion.
Dissertation Publishing
UMI DP22869
Published by ProQuest LLC (2014). Copyright in the Dissertation held by the Author.
Microform Edition © ProQuest LLC.
All rights reserved. This work is protected against
unauthorized copying under Title 17, United States Code
ProQuest LLC.
789 East Eisenhower Parkway
P.O. Box 1346
Ann Arbor, Ml 48106- 1346
UNIVERSITY OF SOUTHERN CALIFORNIA
THE GRADUATE SCHOOL
UNIVERSITY PARK
LOS ANGELES, CALIFORNIA 90007
Ph.D.
CpS
*43
LI 0 5
3PT5E/, 5-f
This dissertation, written by
under f/ie direction of h .is Dissertation
Committee, and approved by all its members,
has been presented to and accepted by The
Graduate School, in partial fulfillment of re
quirements for the degree of
DOCTOR OF PHILOSOPHY
D ean o f Graduate Studies
Date N ovem b er^ 1 9 A 1993
DISSERTATION COMMITTEE
C>6-•Chairperson
i k d & M . . . . : ...........................
Co-G'Kairperson
To my parents,
my wife, and
my daughters Shirley and Katherine
A ck n ow led gm en ts
I am indebted to my advisors Dr. Sarma Sastry and Dr. Massoud Pedram for
their continuous support, constant encouragement, and guidance. W ithout their
help, this research would have not been possible.
I would like to express my thanks to my friends King Ho, C. P. Ravikumar,
and Tzyh-Yung Wuu for many fruitful discussions. I have had the good fortune
of meeting many wonderful people at USC. In particular, I would like to thank
Chihshun Ding, Sasan Iman, Wei-Ming Lin, Bahman Nobandegani, Kuo-Rueih
Pan, and Hirendu Vaishnav.
The funding for my research was provided by Powell Foundation Grant for
Research in VLSI and National Science Foundation’s Research Initiation Awards
under contract No. MIP-9111206 and MIP-9211668. I gratefully acknowledge that.
I am grateful to my father and mother who encouraged me to pursue academics.
Above all, I would like to thank my wife, Jane, and my daughters, Shirley and
Katherine, for their love and support, and for coping with the hardships of graduate
student life.
iii
C on ten ts
List O f Tables vii
List O f Figures viii
1 Introduction 1
1.1 CAD for VLSI Design .............................................................................. 1
1.2 Logic S y n th e sis........................................................................................... 3
1.3 Logic V erification........................................................................................ 4
1.4 Design Data R ep resen tatio n.................................................................... 6
1.5 Integer Linear Program m ing.................................................................... 7
1.6 Organization of the T h e s is ....................................................................... 8
2 Edge-Valued B inary-D ecision D iagram s 10
2.1 Ordered Binary-Decision Diagrams . . . .......................................... 10
2.2 D efinitions..................................................................................................... 12
2.3 O perations..................................................................................................... 17
2.3.1 Complexity Analysis and Flattened EV BD D s............................ 20
2.3.2 The Additive P ro p e rty ................................................................... 22
2.3.3 The Bounding P r o p e r t y ............................................................... 24
2.3.4 The Domain-Reducing P ro p e rty .................................................. 26
*
2.4 Representing Boolean F u n ctio n s............................................................. 27
3 Logic Verification 33
iv
3.1 The Verification P a ra d ig m ........................................................................ 35
3.2 Structured E V B D D ..................................................................................... 37
3.3 Ordering S trateg y ......................................................................................... 48
4 B oolean M atching 50
4.1 Matching Filters ........................................................................................ 54
4.1.1 Cardinality of Dependence S e t ..................................................... 55
4.1.2 Cardinality of O n -s e t..................................................................... 56
4.1.3 Sizes of Distance k ........................................................................ 56
4.1.4 Unateness of Input V ariables........................................................ 58
4.1.5 Symmetry Classes of Input V a ria b le s....................................... 59
4.1.6 Use of F i l t e r s .................................................................................. 60
4.1.7 Comparison of F ilters..................................................................... 61
4.2 Don’t Care S e ts ........................................................................................... 64
4.3 Filters Based on Spectral Coefficients.................................................... 65
4.3.1 Spectral EVBDD (SPBDD).............................................................. 68
4.3.2 Boolean Operations in Spectral Domain ................................ 71
4.4 Filters Based on Prime Im plicants........................................................... 75
4.5 Experimental R e su lts................................................................................. 78
5 Integer Linear Program m ing 83
5.1 B ack g ro u n d ..................... 84
5.2 A Model A lgorithm .................................................................................... 86
5.3 The Operator minimize.............................................................................. 91
5.4 D iscussion..................................................................................................... 97
5.5 Experimental Results .................................................................... 98
6 Function D ecom position 101
6.1 Disjunctive D ecom position..........................................................................102
i
v
6.2 Non disjunctive D ecom position.................................................................... 108
6.3 Cut_set In Place .....................................................................................114
6.4 Computing Cut_sets for All Possible Bound S e t s ................................... 120
6.5 Multiple-Output D ecom position.................................................................126
6.6 Incompletely Specified Functions ..............................................................129
6.7 Experimental R e su lts.................................................................................... 131
7 C onclusions 134
vi
L ist O f Tables
4.1 Comparison of filters................ 63
4.2 Experimental results of Boolean matching................................................ 79
4.3 Experimental results of SPBDDs.................................................................. 81
4.4 Experimental results of PBDDs.................................................................... 82
5.1 Experimental results of ILP problems.......................................................... 100
6.1 Finding all decomposable forms with bound set size < 4 ........................133
L ist O f F igu res
2.1 OBDD representation of a full adder:(a) carry (b) sum.............................. 12
2.2 Two examples........................................................................................................ 15
2.3 Examples for proving canonical property..................................................... 17
2.4 Example of the apply((0, f), (0, g), + ) operation........................................ 19
2.5 The (c„, v ) ’s of X2 ................................................................................................ 21
2.6 An example of flattened EVBDD...................................................................... 21
2.7 A full-adder represented in EVBDDs: (a) carry (b) sum ......................... 29
2.8 A full-adder represented in OBDDs: (a) carry (b) sum ..................................29
3.1 EVBDD expression: 2carry + sum ................................................................... 34
3.2 EVBDD expression: x + y + z ........................................................................... 34
3.3 Graphical representation of SEVBDDs............................................................ 38
3.4 Examples of SEVBDDs........................................................................................ 39
3.5 Examples of type graph of SEVBDDs............................................................. 40
4.1 A simple example................................................................................................ 51
4.2 The operation of replace_root.......................................................................... 52
4.3 The new obddg after replace_root.................................................................... 53
4.4 Function carry represented by (a) OBDD (b) CBDD (c) PBDD................. 78
5.1 A simple example (using flattened EVBDDs and OBDDs).............................87
5.2 Pseudo code for ilp.minimize........................................................................... 89
viii
5.3 An example for conjoining constraints...................................................... 90
5.4 An example for the m inim ize operator.................................................... 96
6.1 A function represented in (a) OBDD and (b) decomposition chart. . 103
6.2 Disjunctive decomposition.............................................................................. 105
6.3 An example of disjunctive decomposition................................................... 108
6.4 Nondisjunctive decomposition........................................................................... I l l
6.5 An example of nondisjunctive decomposition.............................................113
6.6 An example of coded decomposition chart..................................................115
6.7 The decomposition chart with respect bound set {xo,X 2 ,x 4}................ 118
6.8 An example for cut_set in place.....................................................................119
6.9 Operations include and exclude in the decomposition chart............... 121
6.10 Operations include and exclude in the EVBDD representation. . . . 121
6.11 An example of the application of cutlet-all..............................................124
6.12 Example continued...........................................................................................124
6.13 Example continued...........................................................................................125
6.14 An example of cut_set in EVBDD...................................................................127
6.15 An example of disjunctive decomposition in EVBDD................................ 129
6.16 Representation of multiple-output functions.............................................. 130
ix
A bstract
As scale of integration in VLSI chips increases, designers are paying more at
tention to the computational efficiency of the CAD tools. The key to developing
efficient algorithms is a concise, yet effective, representation of functions. This
function representation must satisfy two important attributes: canonicity and com
pactness. A canonical representation simplifies the detection of function properties
such as unateness and symmetry checking. A compact representation ensures the
efficiency of function manipulation.
Ordered Binary-Decision Diagram (OBDD) is a compact, canonical, graphical
representation of Boolean functions. OBDDs have been used in many tasks encoun
tered in computer aided design, combinatorial optimization, m athem atical logic,
and artificial intelligence. While OBDDs are very effective for problems which can
be solved through symbolic Boolean manipulation, they are not so effective for
those requiring arithmetic operations in the integer domain.
This thesis presents a new data structure called Edge-Valued Binary-Decision
Diagram (EVBDD) which can represent and manipulate integer functions more effi
ciently than the OBDD representation. Because Boolean functions are special cases
of arithmetic functions, EVBDDs can also be used to represent Boolean functions.
W ith this property, EVBDDs are particularly useful for applications which require
both Boolean and integer operations. This thesis also contains a number of ap
plications which demonstrate the effectiveness of the EVBDDs and OBDDs. These
applications include the following: showing the equivalence between a Boolean
function and an arithmetic function, solving integer linear programming problems,
showing the equivalence between two Boolean functions modulo input/output per
m utation, and function decomposition for the synthesis of multilevel circuits and
look-up table based field programmable gate arrays.
x
C h ap ter 1
In tro d u ctio n
1.1 C A D for V L SI D esig n
As scale of integration in VLSI chips increases, the need for computer-aided design
(CAD) tools that can quickly produce correct and near-optimal designs increases.
Efficient data structures and algorithms are the key to developing such tools.
The goal of CAD tools is to automate the transformation from the highest
level of abstraction in the behavioral domain to the lowest level in the physical
domain. There are five different levels of abstraction: system, algorithmic, register-
transfer, logic, and physical design level. Different levels require different synthesis
techniques to improve the design quality and verification tools to ensure the design
correctness.
System-level synthesis transforms a system-level specification (protocols and
processes) to one or more subsystem descriptions at the algorithmic level. The
techniques used are system-level partitioning and behavioral transformations [72].
Proof theory and theorem-prover are very useful for proving the correctness at this
level. For example, an arbiter was proved in [5] by using first-order logic and a
microprocessor was proved in [24] by using higher-order logic.
1
The behavior of the algorithmic level is specified as operations and computation
sequences on inputs to produce required outputs. Algorithmic-level synthesis, or
high-level synthesis, performs the following tasks: functional units of appropriate
types and number have to be selected, operations have to be assigned to time
slots, and operations need to be assigned to specific functional units. These tasks
are called resource allocation, scheduling, and resource assignment, respectively.
Examples of CAD tools for high-level synthesis are ADAM [77], CADDY [45], HAL [81],
and OLYMPUS [35]. Verification techniques used in this level are the ones used for
proving the correctness of software programs [33, 71].
Finite state systems are the behavioral description for the control path at the
register-transfer level. Typical synthesis tasks for controllers include the selection
of an appropriate controller architecture, state assignment, input/output encoding,
and decomposition of controllers into smaller interacting finite state machines.
Examples of synthesis tools at this level include CAPPUCINO [34], MUSTANG [36],
and NOVA [99]. CIRCAL [73] used a combination of finite state machines and event
models to prove the equivalence of finite state systems. Recently, ordered binary-
decision diagrams (OBDDs) [16] has been used to model and prove the equivalence
of finite state machines [25].
At the logic level, the behavior is described by Boolean functions. Logic synthe
sis is often divided into two-level and multilevel. Although the two-level synthesis
is simpler, the multilevel synthesis usually produces much more compact, thus eco
nomic, designs. The tasks performed in this level are finding minimal covers for
two-level logic and extracting common sublogic for multilevel logic. The most suc
cessful tools for logic synthesis are ESPRESSO [14] (for two-level) and M IS [15] (for
multilevel). Showing the equivalence of Boolean functions is conventionally car
ried out by tautology checking. Because of the canonical and compact properties
of OBDDs, verifying Boolean functions using OBDDs has become popular [70].
2
At the physical design level, the circuit representation of each component is
converted into a geometric representation. The tasks performed at this level in
clude partitioning, floorplanning, placement, routing, and compaction. Examples
of layout tools are [62, 101], Bear [30], and TimberWolf [90]. Design verification
consists of design rule checking and circuit extraction. Design rule checking is a
process which verifies that all geometric patterns meet the design rules imposed
by the fabrication process. After design rule checking, functionality of the layout
is verified by circuit extraction. Examples of these tools are DRC and EXTRACT
commands in MAGIC [67].
1.2 L ogic S yn th esis
Logic synthesis denotes the problem of transforming a specification to an imple
mentation such that some cost functions are minimized. Logic synthesis usually
contains two phases: a technology-independent step which manipulates general
Boolean functions and a technology-mapping step which maps Boolean functions
into a set of devices in a specific target technology.
The technology-independent phase in logic synthesis is usually divided into two
substeps: logic restructuring which identifies common sublogic to produce a near-
optimal structure and logic minimization which optimizes the logic with respect to
the structure obtained in the previous step. This thesis only considers the problem
of identifying common sublogic.
There are two approaches for identifying common sublogic: algebraic and
Boolean methods. The algebraic methods are fast because the logic function is
represented and manipulated as an algebraic expression. Some optimality may,
however, be lost as Boolean identities are not exploited by the algebraic methods.
3
The algebraic approach is based on the division operation, namely, / = qd + r
where q, d, and r are the quotient, divisor, and remainder, respectively. The theory
of division was studied by Bray ton and McMullen [13] and well developed in the M IS
package [15]. The problem thus reduces to that of finding good divisors. Because
the number of divisors is huge, usually only a subset of the divisors are used. For
examples, [15] uses kernels (cube-free primary divisors) and [98] uses double- and
single-cubes. Division can be carried out by algebraic [15], coalgebraic [52], and
Boolean [15] methods. The division-based methods are directly applicable to both
single- and multiple-output functions.
The Boolean approach is based on the decomposition operation, namely, f( X , Y)
— f'(g (X ), Y) where the number of inputs of f is smaller than that of / . The
theory of decomposition was pioneered by Ashenhurst [1], Curtis [27], and Roth
and Karp [82]. Because Boolean methods usually take more time to operate, an
effective representation and efficient manipulation of functions is the key to the
success of these methods. For representing functions, Karnaugh maps, which are
not a compact representation, are used in [1, 27, 50] and cubes, which are not a
canonical representation, are used in [54, 61, 82].
1.3 L ogic V erification
Logic verification denotes the problem of showing the equivalence between a spec
ification of the intended behavior and a description of the implemented design.
Based on how circuit behavior is modeled, two logic verification approaches can
be identified: logical and functional approaches. In the logical approach, a circuit
is viewed as an entity which ‘formulates’ a predicate by itself [9, 19, 49]. It takes
an (input, output) pair and returns a value true or false. Logical inference is the
main technique to show the equivalence relation between two behaviors. The main
advantage of this approach is that the proof theory and theorem-provers are well
4
developed. The expressive power of higher order logic [19, 49] and the capability
of modeling timing behavior of interval temporal logic [79] also make this approach
appealing. Some disadvantages of this approach are: not every description is exe
cutable [79], the ‘false implies everything’ problem [19], and it requires experts in
theorem proving (instead of the circuit designer) to setup the proof.
In the functional approach, a circuit is viewed as an entity which ‘denotes’ a
function [6, 10, 16, 25]. Usually, it can process inputs to produce outputs. Thus,
it provides the capability of simulation. A typical technique applicable for this
approach is transformation. That is, transforming from a ‘source’ form (e.g., a
FSM) to a ‘target’ form (e.g., a reduced FSM) based on a set of identity laws or
rewrite rules. Although the basic reasoning technique is restricted to identity
substitutions, the loss of proving power is not as much as expected [10]. Moreover,
circuits modeled by functions are closer to the way designers think, thus it is easier
for them to carry out the proofs themselves.
The correctness of a circuit design can only be proved up to the specification
used. For example, if the behavior of a 64-bit adder is specified through 65 Boolean
functions (64 bits plus carry), then the behavior of arithm etic addition can never
be proved. On the other hand, if the specification language allows to specify the
operator ‘-f ’ directly (e.g., lx -f y’), then the correctness is up to the arithmetic
addition. Although OBDDs have become a popular tool for showing the equivalence
of Boolean functions, they cannot directly verify the correctness of arithmetic
behavior.
When proving the correctness of circuit designs, we may not know in ad
vance the correspondence of inputs between the specification and the implementa
tion. This usually happens when different tools have been used at various stages
which have their own naming conventions. A similar situation also arises in the
technology-mapping stage of logic synthesis. In this stage, we want to map parts
of a Boolean network (synthesized by technology-independent stage) to library
5
cells which represent circuits in a specific technology. In these cases, we need to
perm ute the inputs in order to find the correspondence between pins on the cell
and inputs to the candidate match and show the equivalence. This is referred as
Boolean matching. Existing Boolean matching techniques [68, 69, 87] are aimed
at technology mapping where a Boolean function is usually assumed to have a
small number of inputs (e.g., n < 8). Furthermore, these techniques deal with
only single-output Boolean function. For logic verification, these techniques must
be extended to functions with large number of inputs and/or outputs.
1.4 D esig n D a ta R ep resen ta tio n
One key approach to developing efficient CAD tools is to use an effective representa
tion of functions. An effective function representation must satisfy two im portant
attributes: canonicity and compactness. A canonical representation simplifies the
detection of function properties (e.g., equivalence checking); A compact represen
tation provides the efficiency of function manipulation.
Truth tables, Karnaugh maps, sum of minterms, and exclusive sum of minterms
(fixed-polarity Reed-Muller expressions) are canonical, but not compact, represen
tations of Boolean functions. Applications based on these representations are only
practical for small number of inputs. On the other hand, sum of products, prod
uct of sums, and factored Boolean expressions are compact, but not canonical,
representations of Boolean functions.
Ordered Binary-Decision Diagram (OBDD) [16] is a graphical representation of
Boolean functions which is both canonical and compact. W ith the canonical prop
erty of OBDDs, we can easily detect many Boolean properties such as the number
of supporting variables, the unateness of variables, and the symmetry between
variables. W ith the compactness property of OBDDs, we can effectively carry out
many Boolean operations. For example, tautology checking and complementation
6
take constant time while conjunction and disjunction take polynomial time in the
size of OBDDs. Although the number of nodes in the OBDD representation may
be exponential in the input size, OBDDs have a reasonable size in many practical
applications [66].
Edge-Valued Binary-Decision Diagrams (EVBDDs) [28] can represent and ma
nipulate integer functions more efficiently. Because Boolean functions are special
cases of arithm etic functions, we can also use EVBDDs to represent Boolean func
tions. W ith this property, EVBDDs are particularly useful for applications which
require both Boolean and integer operations.
1.5 In teger L inear P rogram m in g
Integer linear programming (iLP) is an NP-complete [42] problem which appears
in many CAD problems. For examples, [55] used a 0-1 ILP technique to solve the
resource constrained scheduling problem in high level synthesis, [39] formulated
the problem of the optimization of complex data-paths relative to a repertoire of
specified operations as a 0-1 ILP problem, and [21] employed a 0-1 ILP technique
to partition input variables for PL A decomposition.
An ILP problem is to find the maximum (or minimum) of a goal function
subject to a set of linear inequality constraints. Each constraint defines a feasible
subspace which can be represented as a Boolean function. The conjoining of these
constraints (i.e., the conjunction of the corresponding Boolean functions) defines
the overall feasible subspace. The problem is then solved by finding the maximum
(or minimum) of the goal function over the feasible subspace.
7
1.6 O rgan ization o f th e T h esis
The remainder of this thesis is organized as follows. Chapter 2 contains the syn
tax, semantics, operations, and properties of the Edge-Valued Binary-Decision
Diagrams (EVBDDs) [28]. Because Boolean functions are special cases of arith
metic functions, we also can use EVBDDs to represent Boolean functions. W ith
this property, EVBDDs are particularly useful for applications which require both
Boolean and integer operations. Furthermore, EVBDDs enjoy certain properties
such as additive, bounding, and domain-reducing properties, which are not seen in
OBDDs. W ith these properties, we can effectively perform arithm etic operations
and branch and bound algorithms by using EVBDDs.
Chapters 3 describes a verification paradigm based on the interpretation of de
signs [51]. For example, we interpret a design in Boolean function form as imple
menting an arithmetic function. We then can use EVBDDs to show the equivalence
between Boolean functions and arithmetic functions. To cope with conditional
statements and array data structure, EVBDD is extended to Structured EVBDDs
(SEVBDDs) [28].
Chapter 4 presents an OBDD-based Boolean matching algorithm which works
for both logic verification and technology mapping. The algorithm is based on
checking whether two OBDDs are isomorphic. In particular, the algorithm is carried
out in a level-first manner which permits significant pruning of the search space. In
addition, a set of filters which further improve the the performance of the matching
algorithm is presented. It also present a method of analyzing the effectiveness of
a filter and rank the various filters based on their effect/cost ratio.
The application of EVBDDs to solving ILP is presented in Chapters 5. This
approach combines benefits of the EVBDD data structure (in terms of subgraph
sharing and caching of computation results) with the state-of-the-art ILP solving
techniques. In addition, the construction and conjunction of constraints in terms
8
of EVBDDs are carried out in a divide and conquer manner in order to manage the
space complexity.
The theory and practices of OBDD-based function decomposition are investi
gated in Chapter 6. This provides the basis for extracting common sublogic from
multiple-output functions. The set of decomposition algorithms presented handle
disjunctive and nondisjunctive decompositions, decomposition on completely and
incompletely specified functions, and decomposition for single- and multiple-output
functions.
Conclusions are given in Chapter 7.
9
C h ap ter 2
E d ge-V alu ed B in a ry -D ecisio n D iagram s
This chapter first gives a brief review of OBDDs [16]. It then presents the syntax,
semantics, operations, and properties of EVBDDs. It also presents the analysis of
computational complexity of EVBDD operations and the comparison of representing
Boolean functions by EVBDDs and OBDDS.
2.1 O rdered B in a ry -D ecisio n D iagram s
D efinition 2.1.1 [16] An OBDD is a directed acyclic graph consisting of two types
of nodes. A nonterminal node v is represented by a 3-tuple (variable(v), c/u/d/(v),
childT(v )) where variable(v) & {xo, . . . , xn-i}. A term inal node v is either 0 or 1.
There is no nonterminal node v such that childi(v) = childr(v), and there are no
two nonterminal nodes u and v such that u = v. There exist an index function
index(x) € { 0 ,..., n — 1} such that for every nonterminal node v, either childi(v)
is a terminal node or index(variable(v)) < index(variable(childi(v))), and either
childr(v ) is a terminal node or index{variable(y)) < index{variable{childr{y))).
The function denoted by (x, vj, vr) is xfi + x f r where // and f r are the functions
denoted by v/ and v r, respectively. The functions denoted by 0 and 1 are the
constant function 0 and 1, respectively.
10
The following notation are used throughout this thesis.
1. The left edge of a node represent 1 or the true edge and the right edge
represents 0 or the false edge.
2. v represents both an OBDD node and the OBDD rooted by node v.
3. index(y) : the index of the variable associated with node v. If v is a terminal
node, then m dex(v) = n.
4.
, , ,, .. f childAv) if indexiv) = i,
l-child(v,i) = < .
[ v otherwise.
, ,, f childJv) if m dex(v) = i,
r-child(v,z) — <
[ v otherwise.
5. new-obdd(x, 1, r) returns an OBDD node v such that variable(v) = x , childi(y)
= 1, and childT{v ) = r.
D efin itio n 2.1.2 Given an OBDD node v representing f ( x 0, ... ,x„_i) and a bit
vector (b0, ..., &t_i), the function eval is defined as
eval(v, ()) = v,
eval(v, (b0, ..., V_i)) = v',
where v' is the OBDD representing function f(b0, ..., 6t_i, x,-,..., x n_ i). When i is
known, eval(v,p) will be used for eval(v, (bo, ..., where p = 2,~1b0 + . . . +
2°6,--1.
E x a m p le 2.1.1 The carry and sum functions of a full adder represented by
OBDDs are shown in Fig. 2.1. From Def. 2.1.1, function carry is derived as follows:
11
(a) (b)
Figure 2.1: OBDD representation of a full adder:(a) carry (b) sum.
fcarry = x f a + x f b = xy + xyz -f xyz — xy + xz + yz,
fa = y l + yfc = y + yz,
h = yfc + y 0 = yz,
f c = 2 1 + ^ 0 = 2.
From Def. 2.1.2, the evaluation of x = 1 in carry results node a, th at is,
carry( 1, y, z) = a; the evaluation of x = 1 and y = 0 results node c; the evaluation
of x = 1, y = 0, and z — 1 results 1. □
2.2 D efin itio n s
EVBDDs are directed acyclic graphs constructed in a similar way to OBDDs. As
in OBDDs, each node either represents a constant function with no children or is
associated with a binary variable having two children, and there is an input variable
ordering imposed in every path from the root node to the terminal node. There is,
however, an integer value associated with each edge in EVBDDs. Furthermore, the
semantics of these two graphs are quite different. In OBDDs, a node v associated
with variable x denotes the B o o lean fu n ctio n (x A fi) V (x A / r ), where // and
f r are functions represented by the two children of v. On the other hand, a node
v in an EVBDD denotes the a rith m e tic fu n c tio n x(vi + /}) + (1 — x)(vr + f r),
where vt and vT are values associated with edges going from v to its children, and
12
fi and f r are functions represented by the two children of v. To achieve canonical
property, we enforce vT to be 0.
EVBDDs constructed in the above manner are more related to pseudo Boolean
functions [47] which have the function type {0, l} n — ► integer. For example,
f(x , y, z) — 3x + 4y — 5xz with x ,y ,z 6 {0,1} is a pseudo Boolean function, and
/(1 ,1 ,0 ) = 7 and / ( l , 1,1) = 2. However, for functions with integer variables,
we must convert the integer variables to vectors of Boolean variables before using
EVBDDs. In the above example, if x £ { 0 ,... ,5}, then f ( x , y , z ) = 3(4x2 + 2xi +
% o) + 4y — 5(4x2 + 2xi + xQ )z and /(4 ,1 ,1 ) = — 4.
By treating Boolean values as integers 0 and 1, EVBDDs are capable of repre
senting Boolean functions and perform Boolean operations. Furthermore, when
Boolean functions are represented by OBDDs and EVBDDs, they have the same size
and require the same time complexity for performiiig operations. Thus, EVBDDs
are particularly useful in applications which require both Boolean and integer op
erations.
The following definitions describe the syntax and semantics of EVBDDs.
D efin itio n 2.2.1 An EVBDD is a tuple (c, f) where c is a constant value and f is
a directed acyclic graph consisting of two types of nodes:
1. There is a single terminal node with value 0 (denoted by 0).
2. A nonterminal node v is a 4-tuple {variable('v),childi(v),childr(v), value),
where variablefv) is a binary variable x € {a?o,..., a ? n-i}*
There is no nonterminal node v with childi{v) = childT(y ) and value = 0, and
there are no two nodes u and v such that u = v. There exists an index function
index(x) € { 0 ,..., n — 1} such that for every nonterminal node v, either child[(y)
is a terminal node or index(variable(v)) < index(variable(childi(v))), and either
childT(v ) is a terminal node or index{yariable{y)) < index(variable(childT (y))).
If v is the terminal node 0, then index(v) = n.
13
D efinition 2.2.2 An EVBDD (c,f) denotes the arithmetic function c + f where
/ is the function denoted by f. 0 denotes the constant function 0, and (x, 1, r, v)
denotes the arithmetic function x(v + 0 + (1 — x)r.
In the graphical representation of an EVBDD {c, f), f is represented by a rooted,
directed, acyclic graph and c by a dangling incoming edge to the root node of f.
The terminal node is depicted by a rectangular node labelled 0. A nonterminal
node is a quadruple (a:, 1, r, v), where x is the node label, 1 and r are the two
subgraphs rooted at x, and v is the label assigned to the left edge of x.
E x a m p le 2.2.1 Fig. 2.2 shows two arithmetic functions / 0 = 3 — 4a: -f 4xy -\-xz —
2y -f yz and f% = 4a;o + 2a: i + £ 2 represented in EVBDDs. The second function is
derived as follows:
fl ~ 0 + fx0 5
f X o = x0(A + f Xl) + (1 - x0)fXl = 4a:0 + 2xi+a:2,
fxt = Zi(2 + f X2) + (1 - Xl)fx2 = 2X! + X2,
fx2 = x2{\ + 0) + (1 - a:2)0 = x2.
□
Note that an EVBDD requires only n nonterminal nodes to represent an n variable
linear function, for example, Fig. 2.2 (b) is a linear function which can also be
interpreted as a 3-bit integer.
D efinition 2.2.3 Given an EVBDD (c, f) with variable ordering a :0 < . . . < x n- i ,
the evaluation of (c, f) with respect to an input pattern b — (b0, . . . , &i_i), 0 i .
14
(a) (b)
Figure 2.2: Two examples.
From the above definition, function values in an EVBDD representation are
obtained by summing edge values (right edge values are always set to 0) along
the path associated with the input assignment. For example, in Fig. 2.2 (a), the
function value of x = 1, y = 0 and z = 1 is 3 + (— 4) + 04-1 = 0, and the function
value of X2 = 1, x\ — 0 and x0 = 1 in Fig. 2.2 (b) is 0 + 4 + 0 + l = 5.
EVBDD is a canonical representation of functions from {0, l} n to the set of
integers. This is stated in the following lemma.
L em m a 2.2.1 Two EVBDDs (cy, f) and (c5, g) denote the sameTunction (i.e., V6 6
B n,
eval({cj, f), 6) = eval((cg, g), &)), if and only if cy = cg and f and g are isomorphic.
Proof: Sufficiency: If cy = cg and f and g are isomorphic, then V6 eua/((cy, f), b) —
eval((cg, g), b) directly follows from the definitions of isomorphism and eval.
Necessity: If cy ^ cg then let b = ( 0 ,..., 0) be the input assignment to f and g
(e.g., Fig. 2.3 (a)). We have the following
eval((cf ,f),b) = cy ^ cg = eval((cg,g),b).
Thus, we focus on the latter condition on f and g. We want to show if f and g are
not isomorphic, then 36 € B n such that eval((0, f), b) ^ eval((0, g), b). W ithout
loss of generality, we assume index(variable(f)) < index(variable(g)). Let k =
n — index(variable(f)), we prove the lemma by induction on k.
15
Base: When k = 0, f is a terminal node and so is g. Furthermore, f = g = 0.
Thus, f and g are isomorphic.
Induction hypothesis: Assume it is true for n — index(variable(i)) < k.
Induction: We show that the hypothesis holds for n — index(variablef) = k.
Let f = fj,fg,uy).
case 1: n — index(variable(g)) = k, that is, g = (xn-k,g h g rivg)-
If vf ^ vg, let b = {... ,0 ,1 ,0 ,...), that is, bn- k = 1 and 6 ,- = 0,Ve n - k,
then eua/((0,f), b) = vj vg = eval({0,g), b) (e.g., Fig. 2.3 (b)). If vf = vg,
then either fj and gj are nonisomorphic, or fr and gr are nonisomorphic.
su b c ase 1: If fj and gi are not isomorphic, then from n — index(variable(fi)) < k,
n— index(variable(gi)) < k, and induction hypothesis, there exists b =
(bQ , . . . , f e n_i) such that eval({ 0, fi), b) ^ eval(( G , gj), 6). Let bf — (b'0,.. ., b ^ }
such that b 'n_k — 1 and 6- = 6 * for i n - k, then eval((0,f},b') =
eval((vh ii),b') ^ eval((vg, gi), b') = eval((0, g), b') (e.g., Fig. 2.3 (c)).
su b c ase 2: Otherwise, fr and gr are not isomorphic, then by similar arguments,
letting b 'n_k = 0 and £• = / n - k will result in eval((0 ,f ), 67 ) /
eval((Q,g),b').
case 2: n — index (variable^)) < k.
By definition of reduced EVBDD, we cannot have both (v/ = 0) and (fj and
fr are isomorphic). If Vf ^ 0, let bn- k = 1 and 6 ^ = 0 for i ^ n — k,
then et?a/((0,f),6) = vj ^ 0 = eval({0, g), b) (e.g., Fig. 2.3 (d)). (Since
g is independent of the first n — k bits.) Otherwise, fi and fr are not iso
morphic and at least one of them is not isomorphic to g. If ft (fr ) and g
are not isomorphic, then by induction hypothesis, there exist a b such that
eoa/((0,fi(fr )), b) ± eval((0, g), 6). Again, let b 'n_k = 1(0) if fi(fr) is not
isomorphic to g, and b\ = 6 ,- for i ^ n — k, eval((0, f), b') ^ eval((0, g), b1 ). □
16
( a ) ( b )
f J 0
9 J
I '
3/^
(x
3/^
( * 4 )
9 ,
( ■ * 3)
H o
/ /
r \ °
\
/
( c )
\
/
u -
( d )
Figure 2.3: Examples for proving canonical property.
2.3 O p eration s
The following algorithm describes the function (EVBDD) apply which takes (c /,f),
(c3 i g}? and °jP ^ arguments and returns (ch, h) such that Ch+h = (c/-f / ) op (cg+g)
where op can be any operator which is closed over the integers.
In algorithm apply, a terminal case (line 1) occurs when the result can be
computed directly. For example, op = x and (c /,f) = (1,0) is a term inal case
because (1,0) = 1 + 0 = 1, (cg, g) = cg + g, and l x ( c } + j ) = (cg + g) = (cg,g),
thus the result can be returned immediately without traversing the graph.
A comp-table storing previously computed results is used to achieve compu
tation efficiency. An entry of comp-table has the form (/, g, op, h) which stands
for f op g ~ h. To compute / op g, we first look up the comp-table with key
(/, g, op), if an entry is found then the last element of the entry h is retrieved as
the result; otherwise, we perform op on the subgraphs of / and g and store the
17
result in comp-table after the completion of / op g. The entries of comp-table are
used in line 2 and stored in line 18.
After the left and right children have been computed resulting in (chl, hi) and
(chr, h r) (lines 14 and 15), if (cA|,hi) = (chr, h r ), the algorithm returns (cA|,h i) to
ensure that the case of (x , k, k, 0) will not occur; otherwise, it returns {chr, (var, hi,
h r , ch{ —chr)) to preserve the property of right edge value being 0. There is another
table (uniq-table) used for the uniqueness property of EVBDD nodes. Before apply
returns its result, it checks this table through operation find-or-add which either
adds a new node to the table or returns the node found in the table.
apply ((c /,f),(c fl,g ), op)
{
1 if (terminaLcase((cf,{), (cg,g),op) retu rn ((c/,f) op (cg, g)));
2 if (computable Jookup((cf ,f) , (cg, g), op, ans)) return(aras);
3 if (index(f) > index(g)) {
4 (csnSl) = (c 9 + value(g), childi(g));
5 < eflr>gr) = (cg,childr(g))-,
6 var = variable(g)', }
7 else {
8 index(g)\\index(f) = = index(f) & & ; addr(f) > addr(g))
swap({cf ,t),(cg,g)y,
}
where addr{i) is the machine address of EVBDD node f. The above code is carried
out before performing comp-table Jookup in line 2 of apply.
19
2.3.1 C o m p le x ity A n a ly sis an d F la tte n e d EVBDDs
The tim e complexity of operations in OBDD representation is 0 ( | f | • | g |) where
| f | and | g | are the number of nodes of OBDDs f and g. The time complexity of
operations in EVBDD representation is however not 0(\ (c /,f) | • | (cfl,g ) |) where
| (c /,f) | and | (cgy g) | are the number of nodes of EVBDDs (c /,f) and (cg, g). This
is because for an internal node v of (cy, f) or (cg, g), apply may generate more than
one (ct,,v) (lines 4, 5, 11, and 12).
D efin itio n 2.3.1 Given an EVBDD (c/,f) with variable ordering xq < ... < xn-i
and a node v of f with variable we define the domain of v (D*^al), and the
cardinality of v (|| v ||) as follows:
D™al = {cu | (cu,u ) = eval((cf,f),b) where u = v,V6 G B
|v | = | n r ' |-
The cardinality of (c /,f), denoted as || (cy,f) ||, is then given as:
Ifo.OI = EMI-
V€f
Note that || {c/,f) | gives the number of possible (c, v )’s which may be generated
from (Cf, f) by apply.
E x am p le 2.3.2 Let (0,xo) be the EVBDD in Fig. 2.2.1 (b), then ||xo ||= 1, | Xi |
1= 2, ||x 2 ||= 4, 10 1 = 8, and || (0,xo) ||= 15. The (cv,v ) ’s for node x 2 are shown in
Fig. 2.5. □
To have a more precise measure of the time complexity of operations in EVBDD I
representation, we define flattened EVBDDs as follows.
D efin itio n 2.3.2 A flattened EVBDD is a directed acyclic graph consisting of two
types of nodes. A nonterminal node v is represented by a 3-tuple (variable(v),
childt(v), childr(v)) where variable{y) G {^o,.. •, xn_i}. A terminal node v is
20
Figure 2.5: The (cv, v )’s of X2 .
Figure 2.6: An example of flattened EVBDD.
associated with an integer v. Reduced, ordered, flattened EVBDDs are defined in
the same way as OBDDs.
Definition 2.3.3 Given a flattened EVBDD f with variable ordering x0 < ... <
x„_i, the evaluation of f with respect to an input pattern (b0, . . . , 0 • • •, h-i)) if j < * and bj
( x j , l,r) if j > i .
1,
0,
E x am p le 2.3.3 The flattened EVBDD for the function in Fig. 2.2 (b) is shown in
Fig. 2.6. □
From the above definition, flattened EVBDDs are exactly the same as Multi-
Terminal OBDDs in [22]. Function values in the flattened EVBDD representation
21
are obtained in the same way as in the OBDD representation. The flattened EVBDD
representation also preserves the canonical property.
L em m a 2.3.1 Two flattened EVBDDs f and g denote the same function if and
only if they are isomorphic.
Proof: The proof of the canonical property of OBDD representation in [16] can
be used to prove the canonical property of flattened EVBDD representation by
replacing terminal nodes 0 and 1 by terminal nodes u and v where t i / « . □
L em m a 2.3.2 Given a function / represented by an EVBDD (c, f) and a flattened
EVBDD f', || !))■
To implement this class of operators, we insert the following lines between lines
1 and 2 of apply:
1.1 cfg = cf op Cg;
1.2 Cf — cg = 0;
We also replace lines 2, 16, and 19 of apply by the following lines:
2 if (comp-tableJookup({cf, f), (c5,g),op, (c/j,h)))
return ((ch + c/5,h});
16 if ((chn hi) = = (chr, hr )) return ((chl + cfg, hj));
19 return ((chr + cfg, h));
For cases of (c/ + / ) x c and (c/ + / ) < < c, we can further separate the
processing of edge values. The following pseudo code times_c((c/,f),c) performs
23
operation (c/ + / ) x c with time complexity 0 {\f |). Note that the new edge value
value(f) x c is computed in line 5 instead of passing down to the next level in line
3 (cf. line 4 or 11 of apply).
times-c((cf, f), c)
{
1 if (f = = 0) return (c/ x c, 0);
2 if (comp-tableJookup({0, f),c, timesuc, (0,h))) return (cf x c, h);
3 (chn h\) — times jc({0,childi({)),c)',
4 (chr1hr) = times-c((0,childr(f)),c)-, /*Chr = 0 * /
5 h = find-.or~add(yariable(i), hi, h r , value(i) x c);
6 comp-tableJnsert({0, f), c, times-c, (0, h));
7 return (c/ x c, h);
}
An im portant application of this class of operators is to interpret a vector of
Boolean functions as an integer function: 2m-1/o -f . . . + 2
2.3.3 T h e B o u n d in g P ro p er ty
Before defining this property, we present a new type of computation sharing
occurring for relational operations. We use operator < as an example. Let
(c/?f) maa:((0,f) — (0, g)) < 0,
— m = m ax((0,f) — (0, g)) < 0,
(cy — cg) < m (cy — cg) — m < 0,
= > (cf — cg) + max((0 ,f) — (0, g)) < 0,
= $ > max((cf , f) - (c5,g )) < 0,
^ (c/>^) — ' (C 3 5S) — V (0,0),
^ (c/ ,f ) — v(c5,g).
Based on the above implication, we replace (cy,f) < (cg, g) by two operations:
(cy,f) — (c5,g) = (c/i,h) and(c^,h) < (0,0). We store the maximum and minimum
function values with each EVBDD node and have the following terminal cases:
if (cy + maa;(f)) < 0 return (1, 0), and
if (cy + m m (f)) > 0 return (0,0).
Another im portant reason for the inclusion of the maximum and minimum val
ues in each node is that we can easily incorporate branch-and-bound algorithms
into EVBDD representation and thus can solve optimization problems more effec
tively.
Definition 2.3.5 An operator op applied to (cy, f) and (c3,0 ) is said to satisfy
the bounding property if
((cy + m (f)) op cg) = 0, 1, or (cy + / ) ,
where rn(f) is the maximum or minimum of / .
As a result, when the maximum or minimum of a function exceeds a boundary
value (e.g., cg in Def. 2.3.5) in an operation, then the result can be determined
without further computation.
25
As an example, the following pseudo code leqO((cj, f)) performs operation (c/ +
/ ) < 0:
leqO((cf, f))
f
{
1 if ((Cf + max(f)) < 0) return((l, 0});
2 if ((c/ -f m m (f)) > 0) return({0,0));
3 if (compJableJookup({cf, f ),leq0, ans)) return(ans);
4 (c/j{,hi) = leq0({cj + value(f),childi(f)));
5 (chr,h r) = leqO({cf,childr(f)))-
6 if ({cftn hi) = = (cAr,h r)) return ((cfc|,hi));
7 h = find-or-add(variable({),hi,hT,Ch, — c^r);
8 comp-tableJnsert((cf ,f), leqO, (c^r,h));
9 return ((cfcr,h));
}
2 .3 .4 T h e D o m a in -R e d u cin g P ro p er ty
In (C/,f) op (c3, g) where op satisfies the additive property, exactly one (0,v) pair
is generated for each node v of f and g. Thus, the ‘effective’ domain of each node
becomes {0}. There are other operators which have similar effect on reducing the
domain of EVBDD nodes.
Definition 2.3.6 Given an EVBDD (c /,f), the domain of a node v of f with respect
to an operator op is defined as:
D°p = {cv | (cvjV^s are the pairs that need to be generated with respect to op}.
Definition 2.3.7 An operator op applied to (c/, f) and (cg, g) is said to satisfy the
domain-reducing property if there exist some node v of f or g such that 'Dff C D^fal.
26
An example of this is the following:
(c/ -f / ) mod c = ((c/ mod c) + / ) mod c.
The domain of a node v of f is D™od = D*fal H { 0 ,..., c — 1}. In this case,
(cf -f A rc , f) can share the computation result of (cf, f) for any integer k. When c
is small, computation sharing is large; when c is large, then the following check
(using the boundary property) can be used to increase the computation saving:
if ((c/ + maar(f)) < c 8z& c (c/ + rain(f)) > 0) then (c/,f).
Another example is integer division operator with constant divisor:
(c/ + f ) / c = (cf / c) + ((c/ mod c) + f)/c,
assuming both c/ and c are positive integers for this example. In fact, integer divi
sion operator with constant division satisfies the three properties: (cf/c) satisfies
the additive property, (c/ mod c) satisfies the domain-reducing property, and
if ((Cf + max(f)) < c && c/ + m in(f) > 0) then 0
satisfies the bounding property.
2.4 R ep resen tin g B o o lea n F u n ction s
By using integers 0 and 1 to represent Boolean values false and true, Boolean
operations can be implemented through arithm etic operations as shown below:
x A y = xy , (2.1)
x\J y = x + y — xy, (2.2)
x@y = x + y - 2 xy, (2.3)
x = 1 — x. (2.4)
27
Thus, Boolean functions are a special case of integer functions and OBDDs are a
special case of EVBDDs.
E x am p le 2.4.1 The sum and carry of a full adder in EVBDD are shown in Fig. 2.7.
By using the above equations, we have the following arithm etic functions for sum
and carry:
sum = x -f y + z — 2 xy — 2 yz — 2 zx + 4xyz,
carry = xy -f yz -f zx — 2xyz.
□
A full adder represented by arithm etic functions may seem more complicated than
when it is represented by Boolean functions. However, the above equations are only
for converting from Boolean functions to arithmetic functions. Pseudo code apply
is capable of directly performing Boolean operations. For example, Boolean dis
junction is carried out through apply({cj,f), (cg, g), V) with the following terminal
cases:
1.1 if « c /, f) = = (1,0) || < c5, g) = = (1,0)) return((l, 0));
1.2 if « c ,,f ) = = (0,0) 1 (c/,f) = = (cg, g)) return((cff,g));
1.3 if ((ca, g) = = (0,0)) return({c/ , f));
Furthermore, when a Boolean function is represented by an EVBDD, it requires the
same number of nonterminal nodes and nearly the same topology as when it is
represented by an OBDD. This is shown by the following algorithm and lemmas.
A lg o rith m A: Converting a Boolean function from OBDD representation to EVBDD
representation.
1. Convert terminal node 0 to (0,0) and 1 to (1,0).
2. For each nonterminal node (x,-,l,r) in OBDD such that 1 and r have been
converted to EVBDDs as (c/, 1'} and (cr , r'), apply the following conversion
rules:
28
Figure 2.7: A full-adder represented in EVBDDs: (a) carry (b) sum.
(a ) (b )
Figure 2.8: A full-adder represented in OBDDs: (a) carry (b) sum.
(a) (a:,-, (0,1'), (0 ,r'» = > (0, (z,-, 1', r '? 0)),
(b) (a:,-, (0, F), ( l , r ;)> = £ • (1, (a:,-, 1', r', — 1)),
(c) (*i,(l,r),{0,r'))=»(0,{a!ill#,r',l)),
(d) (a:t - ,( l ,l ') ,{ l,r ') ) ^ ( l,{ x ,,F ,r ',0 ) ) .
E x a m p le 2.4.2 Fig. 2.8 shows the OBDD representation of carry and sum. After
Algorithm A, they will be converted to the EVBDDs in Fig. 2.7 □
L em m a 2.4.1 Algorithm A converts an OBDD v to either (0,v') EVBDD or (1, v')
EVBDD.
29
Proof: In step 1, only (0,0) or (1,0) can be generated, and in step 2, only (0,v)
and (1, v) can be generated for some v. □
L em m a 2.4.2 Algorithm A will neither add nor delete any nonterminal node or
edge.
Proof: Directly follows from Algorithm A.
L em m a 2.4.3 Algorithm A preserves functionality. T hat is, given an OBDD v, if
the application of Algorithm A on v results in an EVBDD (c, v'), then v and (c, v')
denote the same function.
Proof: Let v represents a Boolean function with n variables, we prove the lemma
by induction on n.
Base: n = 0. v is 0 or 1 and denotes constant function 0 or 1. From step 1
of Algorithm A, (c, v') = (0,0) or (1,0) and denotes the function 0 + 0 = 0 or
1 + 0 = 1.
Induction hypothesis: Assume it is true for n = 0,..., k — 1.
Induction: Let v be an OBDD node (x, 1 , r) representing the Boolean function
(iA l)V (iA r) where I and r are the functions represented by 1 and r respectively,
and each has less than k variables. By induction hypothesis, 1 and r can be
converted into (c/, 1') and (er , r') such that 1 = ci + V and r = cr + r'. From step 2
of Algorithm A, v will be converted into (c, v') and we need to show (xAl)V(xAr) =
c + v'. In the following, we only prove the correctness of case (b) above, the other
three cases can be proved similarly. In case (b), (c/, F) = (0,1') and (cr,r') = (1, r').
From induction hypothesis, / = 0 + V = /' and r = 1 + r'.
LHS = (i A I)V(j A r)
= xl + (1 — x)r — xl( 1 — x)r
= xl + r — xr — xlr + xlr
= xl + r — xr
= xV + (1 + r') — a:(l + r')
= xV + 1 + r' — x — xr'
30
RHS = 1 + v'
= 1 + x (—1 + V) + (1 — x)r'
= 1 — x + xl' + r' — xr'
= LHS
□
T h eo rem 2.4.1 Given a Boolean function represented by an OBDD v and an
EVBDD (c, v'), then v and v' have the same topology except that the terminal
node 1 is absent from the EVBDD v ’ and the edges connected to it are redirected
to the terminal node 0.
Proof: It directly follows from lemmas 2.4,1, 2.4.2, and 2.4.3 and the canonical
property of EVBDD representation. □
L em m a 2 .4 .4 When EVBDDs are used to represent Boolean functions, exactly
one of (0 ,v ) or ( l,v ) can be generated during the process of apply (lines 4, 5, 9,
13, 14, and 16) where v is a nonterminal node.
Proof: If (c, v) is generated where c ^ 0 and c ^ 1, then eval({c, v), (0,..., 0)) = c
which implies that it is not a Boolean function. If both (0, v) and (1, v) are gener
ated, then there exist 60 and bx such that eval((0, v), b0) = 0 and eval((0, v), &i) = 1
because v is a nonterminal node (i.e., v denotes nonconstant function). Then,
eval((l,v ),6 0) = 1 and eval((l,v ),6 X ) = 2 which again leads to a non-Boolean
function. □
T h eo re m 2 .4 .2 Given two OBDDs f and g and the corresponding EVBDDs (c/, f')
and (cg, g'), the time complexity of Boolean operations on EVBDDs (using apply)
is O flf | • |g|).
Proof: From lemma 2.4.4, since only one (c, v) can exist for every nonterminal
node v during the process of apply, we have | (c /,f) |= | (c/, f) || and | (c5, g) |=||
(cgi S) I I - ^ is well known that the time complexity of Boolean operations in OBDD
31
representation is 0 (\ f | • | g |) where | f | and | g | are the number of nodes in OBDD
representation. From theorem 2.4.1, both representations have the same number
of nonterminal nodes, thus the complexities are also the same. □
Based on the above theorem, we can use EVBDDs to replace OBDDs for repre
senting Boolean functions with the following overhead:
1. An integer representing the dangling edge for each function (graph),
2. An integer representing the left edge value for each nonterminal node, and
3. One addition and one subtraction for each call of apply operation (lines 4
and 20).
In the following chapters, several applications of EVBDDs will be presented.
For the sake of readability, the flattened form of EVBDDs will also be used. In
flattened form, edge values are pushed down to the bottom such that a term inal
node is some integer representing the function value.
32
C h ap ter 3
L ogic V erification
The process of logic verification is to show the equivalence between the specifi
cation of intended behavior and the description of implemented designs. If both
specification and implementation are Boolean expressions, then the correctness can
only be proved up to the Boolean behavior. On the other hand, if the specification
is an arithm etic function while the implementation is a set of Boolean expressions,
then the correctness is up to the arithmetic behavior.
When used for logic verification, EVBDDs provide two advantages over OBDDs.
First, they allow equivalence checking between Boolean functions and arithm etic
functions. Second, they handle hierarchical designs, th at is, the implementation of
a design can be described using previously verified components rather than having
to flatten the design down to the gate level.
This chapter first presents a simple example of how to use EVBDDs to verify the
functional behavior of circuit designs and then describes a verification paradigm for
proving data paths. In order to verify control paths and do hierarchical verification,
EVBDDs are extended to structured EVBDDs. Finally, the input variable ordering
strategy for logic verification will be discussed. 1
1The experimental results in this chapter were generated on a Sun 3/200 with 8 MB of memory.
33
Figure 3.1: EVBDD expression: 2carry + sum.
I P
(x)
Figure 3.2: EVBDD expression: x + y + z.
E x a m p le 3.0.3 We prove that carry(x,y,z ) and sum(x,y, z) implement the full
adder x + y-\-z. T hat is, with the interpretation of (carry, sum) as a 2-bit integer,
we show 2carry + sum = x -f y 4- z. Given a gate-level (Boolean) description of a
full adder, it is easy to construct the EVBDD representation of the carry and sum
functions as shown in Fig. 2.7. Carrying out the expression 2carry + sum results
in the rightmost EVBDD shown in Fig. 3.1. On the other hand, the specification
of the arithm etic behavior of the full adder, x + y + z, represented in EVBDDs is
shown in Fig. 3.2. The equivalence between 2carry -f sum and x-\-y + z can then
be checked by comparing the two rightmost EVBDDs in Figures 3.1 and 3.2. □
As shown in the above example, the implementation of a design is described by
Boolean functions while its behavioral specification is described as an arithm etic
function. The equivalence checking between two different levels of abstraction is
carried out by using one representation - EVBDD.
34
3.1 T h e V erification P a ra d ig m
We are given the following:
1. The description of an implementation:
iffipijC ix, . . . , Xnk) = i • • • j 9m (* * -1 1 j • • • , ^nfc)) ?
where xtj ’s are Boolean variables and gf s are Boolean functions.
2. The interpretation of the input variables Xij’s:
X i = fi(x u , ...,x ij) (for a j-b it integer),
x n - fn(xni, • • •, Xnk) (for a fe-bit integer),
where Xi = /,( x ,i,. . . , x,-p) describes how variables (x,i,..., X{p) should be
interpreted as a p-bit integer through function Thus, Xi is an integer
variable and /,- specifies the number system used. A number system may be
unsigned, two’s complement, one’s complement, sign-magnitude, or residue.
For example, if Xi is an unsigned integer, then fi(xn, ..., Xiv) = 2p-1x,i +
. . . + 2 °xip.
3. The interpretation of the output variables gCs: G = g(gi,. . . , gm)- Again, g
is a function representing a number system.
4. The description of a specification:
SpCC^Xj, . . . , Xn) fi^Xj, . . . , Xn)i
where function / specifies the intended behavior of the implementation.
35
To show imp realizes spec, we show the following equivalence relation:
/ ( A * , ..., = d id ly 9m) o r
f{fl{x 11, x lj)i - ‘ ‘ 1 fn{xnh •••ixnk)) = xnk)i • • • ■ > 9m{xlli •••» ^nfc))-
Using the example in the previous section, we have:
imp{x,y,z) = {carry(x,y,z),sum (x,y,z)),
X = Z,
Y = y,
Z — z,
G = 2carry + -sum,
spec(X, Y,Z) = X + Y + Z.
And, the correctness of the full adder is verified by showing x+y+z = 2carry(x, y, z)
+ sum(x,y,z).
The above paradigm can be reversed to become a procedure for functional syn
thesis. Again, we use the full adder as an example except now the goal imp(x, y, z )
is not given. From the description of spec, we have
sum (x,y,z) = spec mod 2,
carry(x,y,z) = {spec — {spec mod 2 ))/2,
where spec = x + y + z. The following sequence of apply operations on EVBDDs
then produces the sum and carry automatically:
<0,xy} = apply{{0,x), (0,y ), + ),
<0,fa) = apply{{0, z), (0, xy ), + ),
(0, sum ) = apply({0, fa), (2,0), mod),
(0, te m p ) = apply{{0, fa), (0 ,su m ), — ),
(0, c arry ) = apply{{0, te m p ), (2,0),/).
As presented in Sec. 2.3.4, operations modulo and integer division can be ef
fectively carried out in EVBDDs. An application of the above synthesis procedure
is in logic verification without variable binding. For example, we can specify a
64-bit adder as (x + y ’ while the variable sets in the implementation are a ’s and
6’s. In this case, we first convert the arithm etic expression into a vector of Boolean
functions and then use Boolean matching [57] to perform the equivalence checking.
36
E x a m p le 3.1.1 The design (imp) is a 64-bit 3-level carry lookahead adder which
has 129 inputs, 65 outputs, and 420 logic gates. The intended behavior (spec) is
specified as:
unsigned(65) add64(x, y, c)
unsigned(64) x, y;
unsigned c;
{
return(x + y + c);
}
where (64) and (65) declare the number of bits. In the experimental implementa
tion, the generation of 65 EVBDDs of imp (575 nodes in total) takes 1.47 seconds and
the generation of one EVBDD of spec (129 nodes) takes 0.17 seconds. The verifica
tion process which converts 65 EVBDDs into one, performing 264 x &o+ • • - + 2° x & 6 4 ?
and then compares the result with the spec takes 4.48 seconds. T hat is, it takes less
than 5 seconds to show 65 Boolean expressions are really carrying out an addition.
□
3.2 S tru ctu red E V B D D
As shown in the previous section, EVBDDs can be used to show the equivalence
between Boolean expressions and arithm etic expressions. To show the equivalence
between Boolean expressions and conditional expressions, EVBDDs are extended
to Structured EVBDDs, or SEVBDDs for short. For example, the implementation
of a multiplexer can be described as l(x A y) V (x A z)' while the specification can
be described as ‘if x then y else z \ In addition to the specification of conditional
statem ents, SEVBDDs also allow the declaration of vectors.
37
f
f.
1
m
t
P e
(a) (b) t;e) is an SEVBDD if p is an SEVBDD with the {0, 1} range, and t
and e are SEVBDDs. For every input assignment b, the function denoted by
(p — * t\ e) returns the value t(b), if p(b) = 1; otherwise it returns e(b). (This
is the conditional type of SEVBDDs.)
3. [fi,. . ., f m] is an SEVBDD if / i , ..., /m are SEVBDDs. For some input assign
ment b, [ft, ..., f m] returns the vector (ft(b),..., / m(6))* (This is the vector
type of SEVBDDs.)
In graphical representation of SEVBDDs, terminal nodes are atomic type SEVBDDs
(Fig. 3.3 (a)) and there are two types of nonterminal nodes: a conditional node
which has three children (Fig. 3.3 (b)) and a vector node which has an indefinite
number of nodes (Fig. 3.3 (c)).
E x a m p le 3.2.1 Let x,y,z,yo,y\,zo , and z\ be EVBDDs. Consider
1. x, x A y, x A z, and
2. (x A y) V (x A z)\
3. (x — » y \z ), (x — » x A y; z), (x — > y; x A z), (x — ► x A y\x A z), and
38
(a) (b)
Figure 3.4: Examples of SEVBDDs.
4. (x -* > [yo,yi];[*b,2i]);
5. [(x -> y0; Z0), (X -> yi; J8i)] and
6. [(a; A y0) V (iA z0), (x — » • x A yi; x A zi)].
SEVBDDs in groups 1 and 2 are atomic type SEVBDDs; Those in groups 3 and 4
are conditional type SEVBDDs; Those in groups 5 and 6 are vector type SEVBDDs.
Note that the SEVBDDs in groups 2 and 3 represent a 1-bit multiplexer while the
SEVBDDs in groups 4, 5, and 6 represent two 1-bit multiplexers which have the
same control signal x. The graphical representation of those in groups 4 and 5 are
shown in Fig. 3.4 (a) and (b), respectively. □
D e fin itio n 3.2.2 The type graph of an SEVBDD f is obtained by replacing all
term inal nodes of f by a unique term inal node A.
E x a m p le 3.2.2 The type graphs of the SEVBDDs in Fig. 3.4 are shown in Fig. 3.5.
□
SEVBDD would be a canonical representation if two SEVBDDs denote the same
function if and only if they are isomorphic. This is however not true because we
can have two SEVBDDs denoting the same function which have different types (e.g.,
39
0 > ) (a )
Figure 3.5: Examples of type graph of SEVBDDs.
Ex. 3.2.1). However, with proper restrictions, SEVBDDs can still have the canonical
property. T hat is, if two SEVBDDs satisfy those conditions then they denote the
same function if and only if they are isomorphic. In the following, two conditions
are defined such that the subset of SEVBDDs which satisfy these conditions have
the canonical property.
The first condition is to be isotypic which is defined as follows:
D efin itio n 3.2.3 Two SEVBDDs are isotypic if their type graphs are isomorphic.
Equivalently, two SEVBDDs / and g are isotypic if
1. Both / and g are EVBDDs, or
2• / = (Pf -» g = (pg -> tg-,eg), pf and pg are isotypic, tf and tg are
isotypic, and e/ and eg are isotypic, or
3. f = [fi, frn], g = [gi, ,gm\ and every pair of /,• and g{ are isotypic.
E x am p le 3.2.3 In Ex. 3.2.1, the SEVBDDs in groups 1 and 2 are isotypic; the
SEVBDDs in group 3 are isotypic but none of them is isotypic to that of 4; SEVBDDs
in groups 5 and 6 are not isotypic. □
Note that two SEVBDDs which are isotypic but are not isomorphic, may still
denote the same function. In Ex. 3.2.1, the SEVBDDs in group 3 are isotypic but are
not isomorphic, yet they all denote the same function. Given an SEVBDD p — * ■ < ; e,
40
for any input assignment b such that p{b) = 1, the function value of e(6) will not
influence the result; similarly, if p(b) = 0 , then t(b) is irrelevant. Therefore, we can
use operators cofactorx(p,t) and cofactor0(p, e) to transform t and e to t' and e'
such that if p(b) = 1, then t'(6) = t(b) and e'(b) = 0; if p(b) = 0, then t'(b) = 0
and e'(b) = e(b). Consequently, we obtain a reduced form (p — > tf; e') for p — *t',e.
Operator cofactorx(p,t) is carried out in a similar way to the restrict operator
in [25] except for the following differences: When p = 0, restrict returns error
while cofactori returns 0; Restrict applies to Boolean functions while cofactorx
applies to arithmetic and Boolean functions.
The second condition for SEVBDDs to have the canonical property is to be
reduced as defined in the following:
D e fin itio n 3 .2 .4 An SEVBDD is reduced if
1. It is an EVBDD, or
2. It is a conditional SEVBDD of the form {p — ► i; e) with cof actorx(p,t) = t,
cofactoro(p, e) = e, and t and e are reduced, or
3. It is [ / i , . . . , / m] and every /,• is reduced.
In Ex. 3.2.1, the SEVBDDs in groups 1 and 2 are reduced; the last SEVBDD in
group 3 and the one in group 6 are also reduced.
To show the canonical property of the restricted form of SEVBDDs, a function
level is defined on SEVBDDs as follows:
D efin itio n 3 .2 .5 The function level : SEVBDD — > integer is defined recursively
as:
1. level(ev) = 0, if ev is an EVBDD,
2. level(p — * t; e) = 1 -f max{level(t), /eue/(e)},
3. /eu e/([/o,. . . , f m- 1 ]) = 1 + m aa:{/eue/(/o),. . . , level(fm- X )}.
41
In Ex. 3.2.1, the SEVBDDs in groups 1 and 2 have level 0; the SEVBDDs in group
3 have level 1, and the SEVBDDs in groups 4, 5, and 6 have level 2.
L em m a 3 .2 .1 If two SEVBDDs / and g are isotypic and reduced, then / and g
denote the same function if and only if they are isomorphic.
Proof: Necessity: It is trivial to show that if / and g are isomorphic, then they
denote the same function.
Sufficiency: If / and g are not isomorphic, then they denote different functions,
that is, 36 6 B n such that e u a /(/, 6) ^ eval(g, 6). This is shown by induction on
level(f).
Base: level(f) = 0, then both / and g are EVBDDs. This is true from lemma 2.2.1.
Induction hypothesis: Assume it is true for level(f) < k.
Induction:
Case 1: / = (p — ► t f ; e/) and g = (p — * tg; eg).
Since / and g are not isomorphic, then tf and tg are not isomorphic and/or e/ and
eg are not isomorphic. If tf and tg are not isomorphic then by induction hypothesis
there exists 6 such that eval(tf,b) ^ eval(tg,b). Because tf and tg are reduced,
that is, if eval(p,b) — 0 then eval(tf,b) = eval(tg,b) = 0 by operator cofactorx,
we have eval(p, b) = 1. Thus, eval(f, b) = eval(tf, b) / eval(tg, b) = eval(g, b). By
a similar reasoning, we can show that the induction step holds true when ef and
eg are not isomorphic.
Case 2: / = [/i,..., f m] and g = [gx, . . . , gm].
There exist 1 < i < m such that f and gi are not isomorphic and from induction
hypothesis there exists 6 such that eval(fi,b) ^ eval{g^b). Then, eval(f,b ) =
{..., eval(fi, 6 ) , . . ^ , eval(gi, 6),...) = eval(g, 6). □
After proving that isotypic and reduced SEVBDDs enjoy the canonical property,
we need procedures for converting an SEVBDD from one form to another and/or
reducing an SEVBDD. Operator cofactorx and cofactorQ are used for converting
42
from atomic (EVBDDs) to conditional form. To convert from conditional to atomic
form, we use operator ite which is nearly the same as the one described in [12]
except that the ite operator used here also applies to arithmetic functions. Op
erator ite takes a conditional SEVBDD such as (p — > t \ e) (t and e are EVBDDs) as
argument and returns an EVBDD / such that (p — > t; e) and / denote the same
function. The following pseudo codes are for converting the forms of SEVBDDs and
reducing SEVBDDs, where cof actor S \ , cof actors0, and i t e s are SEVBDD versions
of cofactori, cof actor and ite, respectively.
convert(f, g) /* converting g to the same form as that of / */
/* assuming / and g have the same number of outputs, e.g., both / and g */
/* are atomic form or vector form with the same number of elements */
{
if ( / is an EVBDD)
if (g is an EVBDD) return(^);
if (g == (p — » £;e)) return(ite(p,convert(f,t),convert(f,e)))]
else if ( / == (p — » t ; e))
return(p — » convert(t, cof actor -Si(p, < ?)); convert(e,cofactors0(p,g)));
else /* f = [fi,‘--,fm]*/
i f ( 9 = = (P - * *5 e ))
return(ite~s(p, convert(f, t),convert(fi e)));
else return([conuer<(/i,5' 1), ...,convert(fm,gm)]);
}
43
reduce(f)
{
if ( / is an EVBDD) return(/);
else if ( / = = (p — > f; e))
return(reduce(p) — » ■ reduce(cof actor s x(p, <)); reduce(cof actor s 0(p, e)));
else return([re t'; e')
return (co / actor s x(p, p') — » • cof actor S\{p, t')- cof actor s x(p, e'));
else /* f = [fl5... ,fm] */
return( [co/acfor_s1(p, tf, et) & :& e = = (pe — > te; ee))
return(e y) retu rn ((l, 0 , 0 ));
else if (x < y) return(( 0 , 1 , 0 ));
else return((gt, It, eq))
}
It takes 0.05 seconds to generate the SEVBDD of imp which has 39 nodes and it
takes 0.02 seconds to construct the conditional SEVBDD of spec which has 25 nodes.
The conversion from the SEVBDD of imp to that of spec and then the comparison |
take 0 . 0 2 seconds. □
45
E x a m p le 3.2.5 The implementation is the SN74181 chip which is a 4-bit ALU
[95]. A partial specification is given below. Note: un-comp, two and unsigned
perform type coercion, un-comp results in an unsigned integer, with the most
significant bit being complemented, two means that the result is to be a two’s
complement integer.
SN74181(M, S, A, B, Cin)
unsigned M, Cin;
unsigned(4) S, A, B;
{
if (M = 0)
if (S = 0) return((un_comp (5)) A + (— Cin));
else if (S = 3) return((two(5)) — Cin);
else if (S = 6 ) return((un_comp(5)) A — B — Cin);
else
if (S = 0) return((unsigned (4)) not(A));
else if (S = l) return((unsigned(4)) not{A o rB ));
}
Note th at it is allowed that the interpretation of the same outputs to differ
ent number systems as well as different sizes in different branches of conditional
statements.
The implementation SEVBDD has 765 nodes and can be generated in 0.31 sec
onds. The specification SEVBDD has 187 nodes and can be constructed in 0.13
seconds. And the verification process takes 0.35 seconds to complete. □
46
In addition to providing the ability to check equivalence between Boolean and
arithm etic expressions and between conditional and nonconditional expressions,
SEVBDDs are suitable for hierarchical verification, i.e., verification without having
to flatten a component which has already been verified. In the following two exam
ples, a 64-bit comparator and a 64-bit adder, the implementations are constructed
from 4-bit comparators and 4-bit ALU’s. The construction of implementation
SEVBDDs are however based on the specification SEVBDDs of the 4-bit comparator
and 4-bit ALU’s.
E x a m p le 3.2.6 The design is a 64-bit comparator implemented through serial
connection of 16 SN74L85s. A net-list description used for this design is as follows:
outl SN74L85 aO a l a2 a3 bO b l b 2 b3 gt It eq
out2 SN74L85 a4 a5 a 6 a7 b4 b5 b 6 b7 outl
o u tl 6 SN74L85 a60 a61 . . . b62 b63 outl5
O utput : o u tl 6
where a net list has the form of : output-name module-name input-nameJist. The
specification of this design is the same as the one in Example 3.2.4 except that
the size declaration is changed from 4 to 64. Generation of implementation and
specification SEVBDDs take 0.26 and 0.39 seconds respectively, and the proof takes
3.35 seconds. □
E x a m p le 3.2.7 The design is a 64-bit ripple-carry adder implemented through
serial connection of 16 SN74181s. The specification of this design is exactly the
same as the one used in Example 3.1.1. A net-list description used for this design
is as follows:
47
scl SN74181 G P G G P aO a l a 2 a3 bO b l b 2 b3 cO
si tail scl
cl head scl
sc2 SN74181 G P G G P a4 a5 a6 a7 b4 b5 b 6 b7 cl
sl5 tail scl5
cl5 head scl5
scl 6 SN74181 G P G G P a60 a61 ... b62 b63 cl5
O utput : si s2 ... sl4 sl5 sc l 6
The first 5 param eters of each SN74181 are connected to the ground or power to
select the addition operation, tail groups all the inputs except the first one (the
most significant bit) while head selects the first bit.
Time to generate the SEVBDDs for the implementation and specification are
2.09 and 0.16 seconds, respectively and time to verify their equivalence is 0.98
second. Note that generation of implementation SEVBDD takes longer tim e while
verification takes less time than the case in Example 3.1.1. This is because, here,
16 SEVBDDs are generated each with the sum of 4 bits instead of 64 SEVBDDs each
with the sum of 1 bit. □
3.3 O rdering S tra teg y
The conditional type of SEVBDDs provides information for determining the ordering
of input variables. For example, for SEVBDD (p — + t\ e), variables occurring in p are
assigned lower indices compared to those in t and e. This ordering strategy matches
the suggestion (controlling variables should be put on top of OBDDs) in [16]. It is
more difficult to identify controlling variables in a Boolean expression. In addition,
variables with larger integer coefficients are assigned lower indices compared to
those with smaller integer coefficients. This ordering strategy also matches the
48
observation in [16], and is easier to identify from arithmetic expressions than from
Boolean expressions.
49
C h a p ter 4
B o o le a n M a tch in g
The problem of Boolean matching is defined as follows:
Given two vectors of Boolean functions (fi(xo,..., a:n_ i), . . f m(x:0,
..., Sn-i)) and (gx(y0, . . y„_i), . . gm(yo, • • yn- 1 )), does there exist
two bijections ir0 : { / i , . . . , f m} -> (yj, • • •, 9m) and *i ■ {^o, • • •, *n- 1 } -+
{yo» • • ■ » Vn-1 } such that fk{x 0 , . . . , X n_X ) = ?ro(/jfc)(7rj(«o), ■ • • , *l{Xn-l)),
for 1 < k < m, where g% — Qk or 1 < k < m, yj = t/j or
y], 0 < j < n?
When such bijections do exist, ( / 1, ..., / m) and (gi,..., gm) are said to be input-
negation, input-permutation, output-negation, and output-permutation equivalent
or npnp-equivalent for short.
A straightforward way to determine whether two Boolean functions are npnp-
equivalent is to explicitly enumerate the set of all bijections, of which there are
2mra!2nn! in number, and perform tautology checking. This is clearly not practical.
This chapter presents a matching algorithm based on the isomorphism checking
on OBDDs which can be carried out in the time proportional to the sizes of OBDDs.
This chapter first describes the basic algorithm for checking input-permutation
equivalence based on two OBDDs and then discusses how it can be extended to
50
u
u
X
(a )
Figure 4.1: A simple example.
check output-perm utation, input- and output-negation equivalences. The various
filters that speed up the process will be presented in the following sections.
Given two functions / and g, we first construct their OBDDs, obddf and obddg.
Then obddg is incrementally transformed to the same form as obddf. The trans
formation is carried out by permuting a subset of variables of g while performing
a check for isomorphism.
To check whether obddf and obddg are isomorphic, the function graphs are
searched in a level-first manner, that is, pairs of nodes to be m apped are added to
a set M. and elements of this set are processed in the order of the index of the node
in obddf. As an example, consider the OBDDs shown in Fig. 4.1. Using a breadth-
first search, the order of processing the elements is (uo, uo)j ui)> (u 2 i v 2 ), • • •
while using a level-first search, the order would be (uo, v0), (u i , ^ 2} ? (mi, Vi), —
At each level i, we perform the following operations. For every (u, v) in M.
such that index(u) = i, we first check index(v). If index(y) = i, we then check
if (child[(u),childi(v)) and (childr(u),childr(v)) will cause conflicts. A conflict
between two nodes exists if both of them are term inal nodes but have different
values, or if one of them is a term inal node while the other one is not. If there
is no conflict, then we proceed to the next level. If indexiy) ^ i or there is a
conflict between childi{u) and child\{y) or between childr(u) and childr{y), then
51
we perform the replace.root operation as shown in Fig. 4.2. In Fig. 4.2(a), the
right child of u and v cause a conflict. Thus, we make yj to be the new root of the
subtree previously rooted at t/» (Fig. 4.2(b)).
After performing replace-root, we carry out another check for isomorphism
starting at level i for the new perm utation (..., yj, yi, y»+i,..., Vj-i, Vj+i, •••, )•
Note th at all the (n — i — 1 )! perm utations of {y0, ■ ■ • ,Vi *) (with y0, . .., iu
fixed in the first i + 1 positions) have been discarded. If yj still fails, then we try
yk which has not yet been tried as a new root. This replace-root operation can
be repeated until no yi can be the new root, at which point we backtrack to level
i — 1 and perform a replace-root operation on ? /* •_ i . Proceeding in this manner, an
isomorphism is found if we advance to level n, or we conclude that no isomorphism
exists when we backtrack to level — 1 .
obddj obddg
P\
" R ' A
A
/ A ' v A '
A - • A /
(a) (b)
Figure 4.2: The operation of replace_root.
In the following procedure replace-root, cofactor creates two OBDDs, obddi and
obddr, such that the functions h, I and r denoted by obddh, obddi and obddr satisfy
h = zl + zr. The procedure new-obdd creates a new OBDD rooted by a node v with
name(v) = z,childi{v) = obddi, and childr(v) = obddr. For every variable z' with
52
Figure 4.3: The new obddg after replace_root.
index(z) > index(z') > index(obddh), procedure updateJndex changes its index to
index(z') + 1 and then changes the index of z to index(obddh).
replace.root^obddh, z)
{
if (index (obdd^) > index(z)) leturn(obddh);
else {
(obdd\, obddr) = cofactor(obddh, z);
obddnew = new-obdd(z, obddi, obddr);
update-index(obddnew, index(z));
return (obddnew);
}
}
E xam ple 4.0.1 As an example of how the above Boolean m atching algorithm
works, consider the OBDDs shown in Fig. 4.1. Initially, M. consists of {(uo^o)}-
At level 0, we first check if index(v0) = 0, and then add (u2 > t> 2 )} to the
set A4. At level 1, since index(u2) = 1 , we check if the index of v2 is 1, as it is in
this case. We then find th at childr(u2) and childr(v2) cause a conflict. Thus we
perform replace-root operation on variable y2. After replace_root, we have the new
obddg as shown in Fig. 4.3 and the steps outlined above are carried out. □
53
For output-permutation equivalence, two vectors of OBDDs are used for iso
morphism checking. To handle input-negation equivalence, the conflict checking
of ( childi(u),childi(v)) and ( childr(u),childr(v)) is replaced by the checking of
(childi(u),childr{y)) and (childr(u),childi{y)). In the basic algorithm, the termi
nal node with value 1(0) is isomorphic with the terminal node with value 1(0),
while in the case of output-negation equivalence checking, the terminal node with
value 1(0) is isomorphic with the terminal node with value 0(1).
4.1 M a tch in g F ilters
An output variable filter is a function F out : {/i,. . . ,/m } — * r, r r,
Xi € (so* •.. ,a;n_i}, r € R(F,n) where R(F m) is some finite set.
To speed up the task of Boolean matching, we examine a set of output and
input variable filters which are derived from the necessary conditions for npnp-
equivalence, that is, they have the properties that if F out{fi) ^ F out(gj) then
(..., /,-,...) and (..., gj, ...) cannot result in npnp-equivalent under gj = Ko(fi),
and if F ,n(f, x t) ^ F m(g, yJ) then /( ..., x,-,...) ^ g(..., y] , ...) under yt = 7rj(x,).
An example of a simple filter is the size of the on-set.
All filters presented in this section are computed using the OBDD representa
tion. A filter can be applied to the entire OBDD prior to the execution of Boolean
matching, or to the subgraph of an OBDD during the execution of Boolean match
ing. Clearly, there is a tradeoff between how expensive it is to compute a filter
and how effective it is in pruning the search space. Section 4.1.7 describes a way
to measure the effectiveness of a filter and provides a comparison of the various
filters based on an effect/cost ratio.
54
4 .1 .1 C a rd in a lity o f D e p e n d e n c e S et
The dependence set of a function f ( x 0, ... ,x n- 1), denoted as Dep(f), is the set
{#,• | 3 two assignments Bi = 6 ,_i, 1, 6*+i,...} and Bq = (..., 6,_i, 0, 6l+i , ...)
such that f(B i) ^ f(Bo)}.
Fdep(f) = l Dep(f) | is the cardinality of the dependence set of / with the range
R(Fdep) — {0,1,..., n). The algorithm for computing the dependence set is shown
below. Dep can be computed in O(m) time, where m is the number of nodes of
an OBDD.
Dep(obdd)
{
if (index(obdd) = = n) return(^);
else {
left = Dep(childt(obdd))’ ,
right = Dep(childr(obdd))]
return(/e/< U right U index (obdd));
}
}
Fdep can be used during Boolean matching by applying it to subtrees rooted
at nodes that are being compared. It can also be applied to the outputs of a
m ultiple-output circuit. The latter is particularly useful for circuits th at implement
arithm etic functions where almost every output function results in a unique value
of Ff**. An input variable filter based on the dependence set is Xi) =
true(false), if X{ is (is not) in Dep(f).
55
4 .1 .2 C a rd in a lity o f O n -set
The on-set of a function / ( x 0 ,...,x n_i) is the set of input assignments where
/ = 1 . F™* is the cardinality of the on set of / and can be computed in 0(m)
time and R{F%?) = {0 , 1 ,..., 2 n}.
K T ( f )
i
if (index(f) == n ) return(ua/ue(/));
else {
I _ F out(childi(f)) * 2index(childdf))~indexU)-1
r _ F out(childr(f)) * 2index(childrU))— * ndex(f)— i
return(f + r);
}
}
Fon*'! as defined above, can be used to reduce the number of possible map
pings between the outputs of two multiple-output circuits. It can also be used
to reduce the number of mappings among input variables. For this we define
a function F™(f,Xi) = F™*(f(x0t..., x,-_i, l,xt+1, ..., x ^ ) ) . If =
••• = Fon(f^xh) = Fonid 1 Vh) = ... = F™(g,yjk), then the set of variables
{xtl, ..., x,fc } must be mapped to the set ,yjk}. This property can be
used when attem pting to m atch X j to yj during Boolean matching. Furthermore,
for two functions f ( x 0 ,..., xn_i) and g(y0,..., yn- i ) to be p-equivalent, the multi-
sets {Fj”( / ,x 0),...,F^(/,x„_!)} and {F™(g,y0),..., F™(g, yn-i)} must be the
same. Thus, a new filter F £ ^ ( f) can be defined as {F™(f, x0),..., F™(f, xn_x)}.
4.1.3 S izes o f D ista n c e k
Let Dk{f) denote the set of pairs of one-points of /(x 0, ..., xn_i) whose Hamming
distance is k. Then =| Dk(f) | and R{F%1) = {0,1,..., F™1
56
represents a set of filters. F ^ 1 can be applied to the outputs of a m ulti-output
circuit prior to executing Boolean matching, thereby reducing the num ber of pos
sible mappings between the outputs of two circuits. can also be used while
performing Boolean matching. The following algorithms show how to determine
F ^ f and F % £_ . In general, the computation of F ^ 1 can be carried out in the same
way as of F^ x.
F£?(obJJ)
{
if (index(obdd) = = n) return(O);
else {
dn = F°^t(obdd-and(childi(obdd),swap(childr(obdd))))',
if (index(ckildi(obdd)) > index (childT (obdd)))
r e t u m ( d n * Q in de x (ch ild r (°b d d ))—index(obdd.) — \
else return (dn * 2index^ hild^ obdd^ - index^obdd^~1)]
}
}
swap(obdd)
{
if (index (obdd) == n) return (obdd)}
else return(neio_o6 dd (variable(obdd), swap(childr(obdd')),
swap(childi(obdd))))\
}
In F£*f, both F™* and swap take 0(m ) time, but the operation of obdd-and(u, v)
takes 0 ( m 2) time. Thus, the complexity of F £f is 0 (m 2).
57
F t.,(o b d d )
{
n l = 0 ;
for (i = 0 ; i < n; i + -f) {
cof actor (obdd, Xi, obddi, obddr);
left = F ff1 (update J,ndex(obddi, Xi))-,
right = Ffff (update J,ndex(obddT, xf));
nl = n l + left + right;
}
return(nl);
}
Both cofactor and updateJndex take 0(m ) time while F f f f takes 0 ( m 2) time,
thus the complexity of F % f f is 0 (n m 2). In general, the complexity of comput
ing distance n — k is 0(C%m2). Similar to F™(f,X{), we define Fi:(f,xi) =
Fd ? ( f{-• • > x% -1» h x*+ 1» • • •))•
4 .1 .4 U n a te n e ss o f In p u t V ariab les
A variable x,- is monotone increasing (monotone decreasing) in a function / if for all
input assignments of Xj ^ x,- / ( ..., x 1+1, ...) < (>) / ( ..., x,_i, 1 , x,-+i,...).
A variable x,- is binate in / if x,- is neither monotone increasing nor monotone
decreasing.
The unateness of an input variable can be used as a filter F ™ ate( f , X i ) £
{inc, dec, binate}. This property can also be used as an output variable filter in the
following way. Let S inc( f ) = {xt - | F ™ ate( f , x,) = inc}. S dec( f ) andS binate(f) are
defined similarly. Then the cardinalities of these sets define the filter F°^ate( f ) =
(I Sine |) | S dec |, | iS binate
|) with R(F%£U) = {(ra,0,0), (n — 1 ,1,0), < n - 2 , l , l ) ,
(0,0,n)} and | |= C „ " «
58
The function F™ate(f,Xi) can be computed in 0 (m 2) as shown below:
Kl«te{°hddixi)
{
cof actor {obdd, x obddij obddT );
if (obddjoperator(obddi, obddr, > )) return(m c);
else if (obdd-operator(obddi, obddr, < )) return(dec);
else return( 6m aie);
}
4 .1 .5 S y m m e tr y C la sses o f In p u t V ariab les
Two variables X j and Xj are symmetric if they can be interchanged without chang
ing the function value, that is, / ( . . . , Xj, . . Xj, ...) = / ( . . . , xj, ..., Xj,...). We
can determine if x,- and Xj are symmetric by testing if / ( . . . , x,_], 0, x*+1, ...,
Xj-j, l,x J+1, ...) = / ( . . . , 1, a!i+i, Xj_i, 0, Xj+i, ...)• The following al
gorithm returns true if x; and xy are symmetric under the function denoted by
obdd.
symmetry (obdd, x,-, xj)
{
cof actor (obdd, xob d d it, obddn );
cofactorfobddii, xj, obdd^ij, obddiiTj)]
cof actor (obddTi, xj, obddTii}, obddriTj);
return(o 6 dd;ir> = = obddrii});
}
Let Ssym(f) be the maximal symmetry classes of / , that is,
Fsym(f} — {X \ 5 • • • i Xk}, 53X% = {xo,..., xn_ j} •, X% O X j — < j> , Xj and
Xj are symmetric if and only if X j € X\ and Xj € Xi, for some 1 .
59
The input and output variable filters based on S3ym(f) are
F%LU) = { | X , | , . . . , | X t |}and
FS,Jf,Xi) = I X, I, where x, € X,.
The ranges of these filters are R(F™^) = {{1,..., 1}, {1,..., 1,2},..., {n}}
and R{Flym) — {1,..., n}. The cardinality of R{F°y^) is the number of decompo
sitions of the integer n.
4 .1 .6 U se o f F ilters
This section explains, by the way of a small example, how the various filters can
be used. Consider the following Boolean functions each of which has three inputs
a, 6 , and c, where
f{a, b, c) = ab + be + abc,
g0(a,b,c) = ab + abc,
gi(a,b,c) = bc+bc,
g2 (a,b,c) = ab + bc + ac,
# 3 (a, b, c) = ab + ac + abc, and
g*{a, b, c) = ab + ac+bc.
We want to find out which of s are p-equivalent to / . Applying F%£ to the
above functions results in
: (f,9o,gi,g2,g3,g4) = (3,3,2,3,3,3),
which prunes g\ . Then we apply F™* and get
F% n '• (f , 9 0 , 9 2 , 9 3 , 9 4 ) = {4,3,4,4,4).
60
This filter prunes function go. Next, we apply F™ to the rest of functions:
* £ (/(< ., 4,«:)) = (2,1,2),
F'2(m) = (2,1,3),
f £ ( m ) = (1,2,2), and
* £ ( * ) = (3,1,3).
By comparing the multi-sets of F™ we know that both <72 and <74 cannot be
p-equivalent to / . Furthermore, variable b of f can only be m apped by variable a
of g3 because they have the same F™ value. This reduces the number of possible
mappings among the inputs between / and g3 to 2! instead of 3!.
Alternatively, instead of using F™ as an output filter we can use F™* to prune
g-i and <74 because
W , 92,93, 9 4 ) = <2,3,2,3),
Fd?(f,92,g3,g4) = (3,2,3,3), and
V ( 1 , 9 2 , 9 3 , 9 4 ) = ( 1 , 1 , 1 , 0 ).
4 .1 .7 C om p arison o f F ilters
As mentioned earlier, there is a tradeoff between the cost of applying a filter and
how effective it is in pruning the search space. To measure a filter’s effectiveness
we need to examine the distribution of values of the filter over the sample space of
all Boolean function of n variables. A filter partitions the set of all 2 2" functions
of n variables into equivalence classes, where two functions belong to the same
equivalence class if they have the same filter value.
Let rj(F, n) be the number of equivalence classes formed by F and N(F, n, k)
denote the number of Boolean functions f of n variables such th at F(f) = k, 0 <
k < tj(F, n ).
Let P(F,n) be the probability that two arbitrarily chosen functions / and
g of n variables result in F(f) = F(g). P(F,n) can be used as measure of a
filter’s effectiveness. The condition P(F\,n) < P(F2,n) implies th at two arbitrary
61
functions will be less likely to have the same filter value under Fi than under F2.
Thus, Fi is more likely than F2 to declare that the two non-jp-equivalent functions
are indeed not p-equivalent. Once we know the number of equivalence classes
r)(F,n) and the cardinality of each class, then P(F,n) is easily computed. This is
given in the following lemma.
L em m a 4.1.1
p < f n) _ a s - 1 "■* ! + * : (4 »
'' ’ * (22" + l)2 2" ‘ ^ ’
P ro o f : The proof rests on the following fact. Given a set of m elements, the
number of ways of selecting j of them without regard to order and with repetitions
allowed is (binomial coefficient). Therefore the total num ber of ways of
selecting two functions from the set of all 22" functions of n variables without
regard to order and with repetitions allowed is Tn = (22” + l)2 2"/2. Using the
same argument, the number of ways of selecting two functions from one of the
rj(F, n ) equivalence classes which has N(F, n, k) elements is
(N(F, n, k) + l)N(F, n, k)
An,k — 2
Therefore,
P(F,n) = A ,'t .
J- n
The result follows since N(F, n, k) = 22". □
As an example, consider F™1 . Then n) = 2n, N{F°^1^ n, k) = C l'”, and
p (Fon^ n) is given by
( 2; r W
' W . ’O = V + V - ^ < « )
62
Filter F Cost | P ( F ) I - 1 =
7 ? ( F > )
Fdep
O(m) n
Fon
0 {m) 2”
Fdk 0 [ C lm k)
C'”2n~1
F unate
o \ m z)
Qn+i
F
* sym
0 (n2m )
1
£
o
Table 4.1: Comparison of filters.
For Ffg, v(FSep, n) = n and N(F$£,n,k) is given by
N(F%, " . * ) = ( £ ) E ( ~ 1 )’ ( • ) 22‘"‘ ■ (4-3)
It can been shown that P (F "“*,n) < P { F ^ 1 n), which implies th at F™1 would be
more effective than F$£*.
Similarly, we can determine the forms of P (P , n ) for each of the filters described
in this section. In this way it is possible to order the filters based on increasing
values of P (P , n). A complete analysis of the filters is beyond the scope of this
section. However, it is possible to get another equivalent but highly simplified
measure of a filter’s effectiveness. This is simply the cardinality of R ( F ) . For
the set of filters discussed in this section, the order obtained using the simplified
measure is the same as the one based on P (F , n). Table 4.1.7 shows the cost of
applying each filter and the cardinality of its range.
Based on the simplistic measure of a filter’s effectiveness, we note th at
1. F on has the best effect/cost ratio, a property that is supported by experi
m ental results 4.5.
2. Although the effect/cost ratio of Fdep is not as good as F on and F dk, it is
very inexpensive to compute. Furthermore, the computation of F on and F dk
requires determining the dependence set.
63
3. The effect/cost ratio of Fdk is moderate for extreme values of k with respect
to n.
Note that in the above analysis, each filter is analyzed independently of other
filters. A much more accurate analysis is possible if the effect of one filter is taken
into account in evaluating another.
4.2 D o n ’t C are S ets
This section presents the effect of Boolean functions with don’t cares on Boolean
matching. A Boolean function / with don’t cares is denoted by (f 0n,fdc) where
the on-set of f on is the on-set of / and the on-set of f dc is the don’t care set of
/ . Before extending the matching algorithm, we have the following definitions and
lemmas.
D efin ition 4.2.1 Two Boolean functions / and g are unifiable, denoted by f = g,
if fon Q g0n + 9 d c and gon C f on -f f dc. T hat is, there exist some don’t care
assignments such that / and g can become equal.
D efin ition 4.2.2 Given two Boolean functions / and g which are unifiable, the
maximum unifier of / and g, denoted by / fj, g, is is the function derived by the
minimum don’t care assignment on / and g such that they become equal.
L em m a 4.2.1 If / = g then / fi g = (hon, hdc) where hon = f on -f gon and
hdc — fdc9dc~
L em m a 4.2.2 If / = g then / fi g = g // / .
\ { f = g A f = h A g = h then ( f p g) p h = f (i (g fi h).
If / S g A ( / fi g) ¥ h then ( / p h V g h).
Lemma 4.2.2 has the following im portant implication: the unification process can
be carried out in arbitrary order without backtracking. More specifically, when a
64
backtrack occurs in the matching algorithm, it is due to a wrong m atch not the
wrong order of unification process.
W ith the above definitions and lemmas, the extension of the m atching algo
rithm to cover don’t care sets is straightforward. A function / now is represented
by two OBDDs obddon and obdddc• The conflict checking in the basic algorithm is
extended to check the unifiable property between two nodes. For example, if a
node u of / is mapped to two different nodes v and v' of g during the matching
process, then we check if v and v' are unifiable. If they cannot be unified, a con
flict results; otherwise we have a possible m atch between u and v" where v" is the
maximum unifier of v and v'.
Since a Boolean function with don’t cares actually represents a set of Boolean
functions, a filter of such a function then becomes a set of values instead of a single
one. For example, F ^ d fo n , fdc)) becomes {F°“*(/on) ,.. •, F °^ t{ f on) + F ^ t ( f dc) } .
Consequently, the testing of filter values between two nodes is changed to ri n r 2 /
< ^ , where r\ and r 2 are sets of filter values.
Note, two variables may be symmetric under one don’t care assignment but not
symmetric under another assignment. Thus, the filtering properties of Fsym (and
Funate) are lost when don’t cares are present.
4.3 F ilte r s B a sed on S p ectra l C oefficien ts
This section presents a set of filters based on spectral coefficients. The main
purpose of spectral methods [100] is to transform Boolean functions from Boolean
domain into another domain so that the transformed functions have more compact
implementations. It was conjectured th at these methods would provide a unified
approach to the synthesis of analog and digital circuits [97]. Although spectral
techniques have solid theoretical foundation, until recently they did not receive
much attention due to their expensive computation times. W ith new applications
65
in fault diagnosis, spectral techniques have recently invoked interest [53]. New
computational methods have been proposed. In [40], a technique based on arrays
of disjoint ON- and DC-cubes is proposed. In [97], a cube-based algorithm for linear
decomposition in spectral domain is proposed.
Recently, [23] proposed two OBDD-based methods for computing spectral coeffi
cients. The first method was to treat integers as bit vectors and integer operations
as the corresponding Boolean operations. The main disadvantage of this represen
tation is that arithmetic operations must be performed bit by bit which is very
time consuming. The second method employed a variation of OBDD called Multi-
Terminal Binary Decision Diagrams (MTBDDs) [22] which are exactly the same as
the flattened form of EVBDDs. The major problem with using MTBDDs is the space
requirement when the number of distinct coefficients is large.
The work on spectral techniques is motivated by the following observations.
First, it is well-known that OBDD-based algorithms have outperformed cube-based
algorithms in many logic synthesis and verification applications. Second, spectral
methods are based on orthogonal transform techniques in which arithmetic oper
ations and integer domain are used rather than Boolean operations and Boolean
domain.
This section presents an EVBDD-based algorithms for computing Hadamard
(sometimes termed Walsh-Hadamard) spectrum [100]. In this approach, the ma
trix representing Boolean function values used in spectral methods is represented
by EVBDDs. This takes advantage of compact representation through subgraph
sharing. The transformation matrix and the transformation itself are carried out
through EVBDD operations. Thus, the benefit of caching computational results
is achieved. The algorithms presented here include both the transformation from
Boolean domain to spectral domain and the operations within the spectral domain
itself.
66
The Hadamard transformation is carried out in the following form:
T n g 7 '
R n, (4.4)
where T n is a 2n x 2n m atrix called transformation matrix, Z n is a 2" x 1 m atrix
which is the tru th table representation of a Boolean function, and R n is a 2n x 1
m atrix which is the spectral coefficients of a Boolean function.
Different transformation matrices generate different spectra. In this section,
we use the Hadam ard transformation m atrix [100] which has a recursive structure
as follows:
'J 'n —X
rp n —1
rpn— 1
and
rp 0
1.
E x a m p le 4.3.1 The spectrum of function f ( x , y ) = x 0 y is computed as
’ 1 1 1 1 '
1
o
1
1
to
1 - 1 1 - 1 1 0
1 1 - 1 - 1 1 0
1 - 1 - 1 1
I
o
1
...1
1
I
The order of each spectral coefficient r,- (ith row of R n) is the number of l ’s in
the binary representation of i,0 < i < 2n — 1. For example, roo is the zeroth-order
coefficient, roi and rio are the first-order coefficients, and r n is the second-order
coefficient. Let = { multi-set of the absolute value of r^’s where r*. is an ith-
order coefficient of R 1}, 0 < i < n. In Example 4.3.1, R q = {2}, R\ = {0,0}, and
R \ = {2}. An operation on / and its R n which does not modify the sets R? is
referred as an invariance operation. Given a function f ( x i , . . . , x n) with spectrum
67
RJ1 , three invariance operations on / and R n are as follows (formal proofs may be
found in [38]):
1. Input negation invariance: if Xi is negated, then the new spectrum R n is
formed by r'k = —rk where the ith bit of it is 1, and rk = rk otherwise.
2. Input perm utation invariance: if input variables Xi and xj are exchanged,
then the new spectrum is formed by exchanging rk s and r/’s where k — 21 =
l — 2j . T hat is, the ith and j th bits of k and I are (1,0) and (0,1), respectively,
while all other bits of k and I are the same.
3. O utput negation invariance: if / is negated, the RJ1 ' is formed by replacing
all rk by - r k.
L em m a 4.3.1 Two Boolean functions are input-negation, input-perm utation, and
output-negation equivalent (npn-equivalent) only if their i?"’s are equivalent.
Proof: For negation equivalent, since | rk |= | —rk |, replacing rk by —rk will not
change R%. For perm utation equivalent, since rk s and r/’s have the same order,
exchanging their values is equivalent to permuting values in multi-set R □
From Lemma 4.3.1, we have a new set of filters: Jf2". The following shows how
to use EVBDDs to represent Boolean functions in spectral domains. The resulting
data structure is called an SPBDD. The function value of an input pattern bo . . . 6n_j
in SPBDDs is an element of R% if the pattern contains i I ’s.
4 .3 .1 S p e ctr a l EVBDD ( s p b d d )
The m ajor problem with Equation 4.4 is that all matrices involved are of size 2n.
Therefore, only functions with a small number of inputs can be computed. To
overcome this difficulty, we use EVBDDs to represent both Z n and RJ1. When an
EVBDD is used to represent R n, it is referred as SPectral EVBDD, or SPBDD for
68
short. The difference between EVBDDs and SPBDDs is in the semantics, not the
syntax. A path in EVBDDs corresponds to a function value while a path in SPBDDs
corresponds to a spectral coefficient. The m atrix m ultiplication by T n is implicitly
carried out in the transformation from Z n to R n (i.e., from EVBDD to SPBDD).
Z n and Rn are recursively defined as follows:
Z n -
ryn— 1
"0
Z ? -1
and
Rn =
Then, Equation 4.4 can be rew ritten as:
.n — 1
O
Rl
D B -
Kq
in — 1
r p n —l r p n —1
' z r 1 '
p n —X ^ n —\
+ p n - \ Z n - 1 '
o n —1
t l 0
r £ n —\ __r p n —1 Z n - 1
p n —l z ™ ~ ^
__ p n —l g n —l
R r 1
Equation 4.5 then is implemented through EVBDD 1 as :
(4.5)
T ({x ,zr\zz~'))
r( 1)
r( 0)
~ r i Z r ^ r i Z r 1) + r i Z r 1)), (4.6)
1, (4.7)
0. (4.8)
where r is the transformation function which converts an EVBDD representing a
Boolean function to an SPBDD. To show the above equations correctly implement
Equation 4.5, we prove the following lemma.
1For the sake of readability, flattened EVBDD is used in this section.
69
L e m m a 4.3.2 Let r : EVBDD — ► SPBDD as defined in Equations 4.6-4.8, then
r implements T, th at is, r ( / n) = T nf n, where f n is an n-input function. Or,
equivalently, r((x n, Z f_1, Z£-1)) = {xn, J??-1 ,
Proof: By induction on input size n.
Base: n = 0, f ° = c is a constant function, c G {0,1},
r(c) = c by Equations 4.7 and 4.8,
T°[c] = [l][c] = [c].
Induction hypothesis (IH): assume it is true for 0 < n < fc — 1, r ( / n) = T " /n.
Induction:
= (x*, t (Zo- 1) - rCZ,*-1) , ^ - 1) + rCZ^-1)) by Equation 4.6
= (x k, T k- xZ ^ -x - T k~xZl~x, T k~l Z%-x + T ^ Z } - 1) by IH
= (xk, TJo-1} by Equation 4.5
□
E x a m p le 4.3.2 The exclusive-or function in Example 4.3.1 is redone in term s of
EVBDD representation.
= (*,7-({y,l,0)) - r « y ,0 ,l) ) ,r ( ( y ,l,0 ) ) + r((y ,0 ,l)))
= {*, <^,^(0) - r ( l) ,r ( 0 ) + r (l)) - (y ,r (l) - r(0), r ( l) + r(0)),
(yM °) - T(1)»r (0) + r (1)> + (y^C1) - T(°)>T(1) + r (°)))
= (x > (y> - 1» i> - ii i)» (y» - i » + (y> i)>
= (* ,< y ,-2 ,o ),(y ,o ,2 )).
□
Pseudo code evbddJospbdd(ev, level, n) is the implementation of Equation 4.5.
Because of the following situation, this procedure requires level and n as parame
ters:
r((x ,z ,z )) = < x ,t ( z ) - t ( z ) ,t ( z ) - |- t ( z ) ) ,
= (x,0,2 x r(z)).
70
In reduced EVBDD, (x ,z,z) will be reduced to z while (x,0,2 x r(z )) cannot be
reduced in SPBDD. We need to keep track of the current level so th at when the
index of the root node ev is greater than level, we generate (level, 0,2 x r(ev))
(lines 3-8).
evbddJto-spbdd(ev, level, n )
{
1 if (level = = n) return ev,
2 if (ev = = 0 ) return 0;
3 if (index(ev) > level) {
4 sp = evbddJtospbdd(ev, level -f 1, n);
5 le ft = 0;
6 right = evbdd-add(sp,sp)
7 return newjevbdd(level, left, right);
8 }
9 spi = evbddJ,ospbdd(childi(ev), level -f l,n );
10 spr = evbdd-to~spbdd(childr(ev), level + 1 ,n);
11 left = evbdd^sub(spT,spi)\
12 right = evbdduadd(spr,spi);
13 return new-evbdd(level, left, right);
}
4 .3 .2 B o o le a n O p era tio n s in S p e ctr a l D o m a in
This section shows how to perform Boolean operations in SPBDDs. It first presents
the algorithm for performing Boolean conjunction in SPBDDs by the following def
inition.
D e fin itio n 4.3.1 Given two SPBDDs / and g, the operator A is carried out in the
following way:
71
f A g = f x g, if / and g are terminal nodes; otherwise,
(x,ft,fr) A (x,gt,gr) = (x, (/( A + f r A f lf t)/2, (// A gi + f r A gr)/2).
The following lemma and theorem prove that the above definition carries out
the Boolean conjunction in SPBDDs.
L em m a 4.3.3 ( f + g)A(i+j) = f A i + fAj+ gAi + gAj, where f,g, i,j €
SPBDD. (Note th at + ’ s may be replaced by — ’ s.)
Proof: by induction on the size of inputs.
Base: n = 0, /, g, i, and j are constant functions.
(/ + 9 ) A ( * ' + j ) from LHS
= ( / + 9) x (* + j) by Def- 4-31
= f x i + f xj -j-gxi + g xj by distributive laws of x and +
f A i + fA j + g A i + g A j from RHS
= f x i + f x j + g x i + g x j by Def. 4.3.1
Induction hypothesis (IH): assume it is true for 0 < n < k.
Induction: let / = (xk,ft,fr), g = ( x k,gt,gT), i = {xk,it,iT), and j = (xk,jt,jr),
where ft, f r, gi, gT, it, ir, jt, and j T have at most k — 1 inputs.
(>^ k , f t , f r ) A { x k , it, i r ) -)- { x k;, f t , f r ) A ( x k , j t , J r ) ” f"
{xk,g t,g T) A ( x k,i t , i r) + ( x k,g t,g r) A (xk,jt,jr) from RHS
= { x k, (ft A ir + /r A *'/)/2, (ft A it + f r A iT) j2)+
(x k , ( f t A j r + f r A j l ) / 2 , ( f t A j t + f r A j r ) / 2 ) +
( ^ j A i r gT A i t ) / 2 , (<7 / A 4 5 r A i T) / 2 ) - \ -
(**, (#< A j r + gT A j t ) / 2 , (gi A j t + gr A j r ) / 2) by Def 4.3.1
= i x k, ( f t A i r + f r A i {) / 2 + ( f t A j r + f r A j t ) / 2 +
{gi A ir + g r A */)/2 + (37 A j r + g r A >i)/2,
(// A it + /r A ir)/2 + (/; A j t + f T A j r ) / 2 +
(gi A it + gT A i r ) / 2 + (gt A j t + gr A j r ) /2) by + in SPBDD
= i p 'k , (// A i r f r A i t - f * //A / • “I ” f r A j t
+gt A *r + gr A + 37 A *r + gr A jt)/2,
(// A l| f r A i , - //A j t "f /r A jr
+fir< A it + gr A iT + gt A jt + gr A jr)/2) by + and /
72
((Xk,fhfr) + {Xk,9h9r)) A ((x k,ii,i r) + (xkJ h j r)) from LHS
(Xk, fi + gi, /r + 9r) A r A t/ + A i^)/2,
( // A i{ + fi A ji +gi A ii + 91 A j'j
-f- ir A ir ir A j r " 4 " 5 V A i'r “ I - P r A Jr)/2) by IH
□
T h e o re m 4.3.1 Given two Boolean functions / and g represented in EVBDDs,
T( f ' 9 ) = = T(f) A t( ((r (/r) - r(fi)) A (T(flfr ) + r{gi))+
(T{fr) + r(/i)) A (r(gr) - r(gt)))/2,
(O'C/r) - r(fi)) A {r{gr) - r (# ))+
(r(fr) + r(fi)) A (r(flir) + r(gt)))/2) (A)
= (**» (r(/r) A r(^r) + T(fr) A T(gi) —
T{fi) A T(srr ) - r ( / , ) A r ( # )+
r{fr) A r(^r) - r ( / r) A r(gt)+
T{fi) A r($r) - r(/,) A r(gi))/2,
(T(/r) A r($r) - r ( / r) A t ^ , ) -
r (/i) A r(flrr) + r(/i) A t ( # ) +
T(/r) A r(gr) + r ( / r) A r (# )+
t(/,) A t( * ) + r(/,) A r(sf,))/2) (LEMMA 4.3.3)
= (**, r ( / r) A r($ rr) - r(/,) A t ( # ) ,
T(/r) A r(pr) + r(/j) A t(#)> (+> /)
□
Other Boolean operations in SPBDDs are carried out by the following equations:
/Vflr = / + fif-/A ^, ( 4 .9 )
f ® 9 = / + J - 2 x ( / A j), (4.10)
/ = J n - / , (4.11)
where V, 0 , an d -, are or, xor, and not in spectral domain (SPBDD),
J n = [2n, 0,..., 0]*.
These operations V, 0 , and- are from [53] with minor modification to m atch the r
operation. Operations + , —, and x are carried out in the same way as in EVBDDs
(Sec. 2.3).
74
4 .4 F ilte r s B a se d on P r im e Im p lica n ts
This section describes a set of filters based on the complete set of prime implicants
of a function and presents OBDD-based data structures and algorithms for efficient
computation of this set of filters.
D efin ition 4.4.1 Given a function f ( x 0, ..., ® n- i) , let
P rim es(f) = {p | p is a prime implicant of /} ,
Pfrt ~ {p \ P € P rim es(f) A p C x},
Pf,x = {P I P € P rim es(f) A p C x},
p f,*e = { p I P € P rim es(f) A p % x A p £ z},
P d f, x) = (m m (| Pf> x |, | PJ < X |), m a x (| Pf> x |, | Pf> x |), | Pf> X e |), and
Pconnt(f) = $Pc(f,x) | X € S U p p o r t ( f ) } .
where -J J represents a multi-set. We have the following propositions. Let F 0U t
and F tn denote output and input filters as defined in Sec. 4.1.
P rop osition 4.4.1 | P rim es(f) | is an F out.
P rop osition 4.4.2 Pc(f,x) is an F tn.
P rop osition 4.4.3 P C O u n t ( f ) is an F out.
To compute the complete set of prime implicants of a function, a variation of
OBDD was developed which is inspired by the Coudert and M adre’s work [26]. In
this variant of OBDD, each nonterminal node has three children left, center and
right and denotes the function xf\ + / c + x f r where f c = fifr. The resulting OBDD
is referred as the Consensus OBDD, or CBDD for short.
The computation of P rim es(f) is carried out in two steps. In the first step,
we generate all prime implicants as well as some nonprime implicants based on the
consensus operation. In the second step, we remove the nonprime implicants.
75
To perform the first step, we must convert OBDDs to CBDDs. The conversion is
described by the following algorithm obdd-to-cbdd.
obdd-to-.cbdd( f)
{
if (f = = 0) return 0;
if (f = = 1) return 1;
fc = obdd-and(ii,fr)',
return cbdd-con struct (variable(f), obddJo-cbdd(fi),
obdd-to-cbdd{fc), obdd-to-cbdd{fr ));
}
where cbdd-construct builds a nonterminal node with root variable(f) and three
children.
After the operation obdd-.to.cbdd, the resulting CBDD contains not only all prime
implicants but also some nonprime implicants. In the second step, we remove the
nonprime implicants from the CBDD using the following formula:
P rim es(f) = (Prim es(fi) — P rim es(fifr)) U (P rim es(fr) — P rim e s(fifr))
U P rim es{fifT)
The operation is carried out by the cbdd-tojpbdd procedure. The resulting OBDD is
referred as Prim e OBDD, or PBDD for short, in which every path to a term inal node
1 corresponds to a prime implicant. Note that, a PBDD f contains all the prime
implicants of function / and its center child contains all the prime implicants of
function fifr, but its left (right) child neither contains all the prime implicants of
fi (f r) nor contains all the prime implicants of fi — f r (f r — //). This is because
the ‘subtract’ (pbddsub) operation is not closed under PBDDs.
76
cbddJt o-pbdd(f)
{
if (f = = 0) return 0;
if (f = = 1) return 1;
h; = cbdd-to-.pbdd(fi);
hr = ebdd-to-pbdd( fr);
new c = cbdd-to-pbdd( fc);
new / = pbddsub(hi, new c);
n ew r = pbdd^sub(hr, n ew c);
return pbdd-construct(variable(f), new;, n ew c, n ew r);
}
pbddsub{ f , g)
{
if (f = = 0) return 0;
if (g = = 0) return f;
if (f = = g) return 0;
if (variable(f) > variable{g))
return pbddsub(f, gc);
if (yariable(f) < variable^g))
return pbdd-construct(variable(f),fi,pbddsub(fc, g), fr);
return pbdd-Construct(variable(f),pbddsub(fi, g/),
pbddsub(fc, gc),pbdd~sub(fr, gr));
}
Filters described in propositions 4.4.1, 4.4.2, and 4.4.3 can be easily constructed
using the PBDDs. For example, | Primes(f) | is equivalent to computing the
number of 1-paths in the PBDD for / .
77
1 0 1 0 1 0
(a) (b) (c)
Figure 4.4: Function carry represented by (a) OBDD (b) CBDD (c) PBDD.
E x a m p le 4.4.1 The function carry of a full adder represented by OBDD, CBDD,
and PBDD is shown in Fig. 4.4. The CBDD representation of carry in Fig. 4.4 (b) is
derived by applying procedure obddJto-cbdd on the OBDD in Fig. 4.4 (a), and the
PBDD in Fig 4.4 (c) is derived by applying procedure cbdd-tojpbdd on the one in
Fig. 4.4 (b).
The set of prime implicants of carry is {xy,yz,xz}. Note th at the implicants
of carry represented by 4.4 (b) are {x y , xyz, xz, y z , xyz} where xyz and xyz are
not prime implicants.
The set of filters defined in this section for carry is as follows:
= 3,
= (0, 2, 1),
= (0,2,1),
= (0,2,1), and
= 1(0,2,1), (0,2,1), (0 ,2,1)1.
□
4.5 E x p erim en ta l R esu lts
The Boolean m atching algorithm and the various filters have been tested on the
MCNC and ISCAS benchmark circuits. For each circuit we constructed two OBDDs.
| Primes(carry) |
Pc{carry, x)
Pc(carry,y)
Pc(carry, z)
Pcount (carry)
78
The second OBDD was generated by randomly perm uting and renaming the vari
ables of the first. Table 4.2 shows the characteristics of each circuit, the number of
nodes in each OBDD and the execution times (in CPU seconds on a Sparc Station
II with 64 MB of memory) for the Boolean matching algorithm w ith and without
the use of various filters. The following legend describes the d ata in each column.
1. A : Boolean matching with no filters used.
2. B : F™ computed and checked during Boolean matching.
3. C : F£ep, F™*, F ^ \ a n d F used in the given order as long as more than two
outputs have the same filter value. These filters are computed and checked
prior to Boolean matching.
4. D : F out filters are used as in C (before matching) and then Fon is used as
in B (during matching).
in,out A B C D
sao2 .T 0 7 I.. 1X39’ 0.85 0.73 0.40
rd73 7 ,3 1.85 O.lO 0.07 0.12
rd84 8 ,4 6.27 0.22 0.02 0.08
misexl 8, 7 13.13 12.52 0.03 o:o9
misex2 .2'Sr;'18 — — "3:68 ' ...r : 8 7 " ..
misex3 14, 14 — — 13.25 6.08
apexl .45; 45.. — - — — 165.80
apex2 39, 3
—
..221.42“ — 62.47
duke2 22, 29 — — 3.50 2.54
c432 36, 7 — 1279.72 29.55 34.10
Table 4.2: Experimental results of Boolean matching.
79
The results displayed in Table 4.2 are summarized below.
• Comparing columns A and B , we find that in those cases where the Boolean
matching was completed in a reasonable amount of tim e, the application of
F™* resulted in speed up ranging from 19 to 28 times.
• Comparing columns A and C , we find a speed up ranging from 17 to 430
times. We also note th at for circuits misex2, misexS, duke2, and c432 the
matching algorithm without any filters had to be aborted. However, use of
the filters and resulted in successful completion within
a very short period of time.
• W hen F™ was applied in conjunction with the filters in {F ^*, F™*, Ffi^,
Fd?*}> then the matching algorithm was successful in all cases.
• For circuits with a small number of inputs, the filters in {F££, F™1, F ^ , F™*}
seem to be more effective than F™. However, F™ is very effective for larger
circuits.
The above results are generated using arbitrary variable orderings for the initial
OBDDs. Using any of the other ordering strategies th at have been reported [12],
we expect further improvement in performance.
Table 4.3 shows the results of some benchm arks represented in both EVBDD and
SPBDD forms. Column ‘EVBDD’ depicts the size and tim e required for representing
and constructing a circuit using EVBDDs while column ‘SPBDD’ depicts the size of
SPBDDs and the tim e required for converting from EVBDDs to SPBDDs. In average,
the ratio of the number of nodes required for representing SPBDDs over th at of
EVBDDs is 6.8, and the ratio of the conversion tim e for SPBDDs over the construction
tim e of EVBDDs is 41.
The performance of a filter depends on its capability of pruning (effectiveness)
and its computation tim e (cost). Experimental results of [23] show that this filter
80
is quite good because it rejected all unm atchable functions th at were encountered.
However, according to results of Table 4.3, this filter is relatively expensive to
compute when comparing with other filters [57]. Therefore, this filter should be
used only after other filters have failed to prune the search space.
In Out EVBDD SPBDD
Size Time Size 'lim e
9symml 9 1 24 0.17 39 0.15
c8 28 18 142 0.09 1310 4.79
cc 21 20 76 0.02 951 1.59
cmb 16 4 35 0.04 88 0.17
comp 32 3 145 0.10 809 35.31
cordic 23 2 84 0.09 208 1.35
count 35 16 233 0.14 1197 8.39
cu 14 11 66 0.04 266 0.67
f51m 8 8 65 0.08 295 0.34
lal 26 19 99 0.07 1111 2.99
mux 21 1 86 0.11 144 0.99
parity 16 1 16 0.02 30 0.14
pcle 19 9 94 0.03 640 1.18
pcler8 27 17 139 0.05 1617 4.53
pm l 16 13 57 0.01 465 0.74
set 19 15 101 0.07 1295 2.42
ttt2 24 21 173 0.23 2046 5.35
unreg 36 16 134 0.04 816 5.78
x2 10 7 41 0.01 305 0.42
z4ml 7 4 36 0.09 83 0.13
b9 41 21 212 0.10 1809 12.08
alu2 10 6 248 0.69 889 2.69
alu4 14 8 1166 3.78 5913 66.12
term l 34 10 614 1.39 5643 104.35
apex7 49 37 665 0.35 3017 52.51
cht 47 36 133 0.08 452 5.19
example2 85 66 752 0.22 5163 23.14
Table 4.3: Experimental results of SPBDDs.
In Table 4.4, columns ‘OBDD’, ‘CBDD’, and ‘PBDD’ depict the tim e required for
constructing a circuit using OBDDs, CBDDs, and PBDDs, respectively. Column
Prim es’ depicts the number of prime implicants of a circuit. Since the construction
of the PBDD filters requires operations similar to those performed while construct
ing we should apply these filters only after has failed to prune the search
space.
81
OBDD CBDD PBDD # Primes
9symml 0.17 0.77 0.05 1680
c8 0.08 0.2 0.07 228
cc 0.02 0.08 0.04 52
cmb 0.04 0.11 0.01 26
comp 0.09 80.73 0.1 196606
cordic 0.06 9.3 0.06 1742
count 0.11 0.39 0.16 336
cu 0.02 0.07 0.05 29
f51m 0.06 0.18 0.09 94
lal 0.05 0.21 0.08 102
mux 0.08 0.84 0.16 81
parity 0.02 0.08 0.01 32768
pcle 0.03 0.08 0.08 81
pcler8 0.04 0.12 0.09 119
pm l 0.02 0.04 0.01 37
set 0.05 0.18 0.11 78
ttt2 0.19 0.51 0.12 160
unreg 0.04 0.12 0.1 112
x2 0.01 0.05 0.03 33
z4ml 0.06 0.15 0.03 59
b9 0.08 0.32 0.14 146
alu2 0.58 2.6 0.47 328
alu4 2.88 38.28 9.51 1980
term l 1.11 7.52 1.44 330
apex7 0.28 1.66 0.99 1027
cht 0.08 0.14 0.08 120
example2 0.19 0.41 0.28 461
Table 4.4: Experimental results of PBDDs.
82
C h a p ter 5
In teg er L inear P ro g ra m m in g
Integer Linear Programming (iLP) is an NP-hard problem [42] that appears in
many applications. Most of existing techniques for solving ILP such as branch-
and-bound [64, 31, 76] and cutting-plane methods [43, 44] are based on the linear
programming (lp) method. While they may sometimes solve hundreds of vari
ables, they cannot guarantee to find an optimal solution for problems with more
than , say, 50 variables. It is believed that an effective ILP solver should incor
porate integer or combinatorial programming theory into the linear programming
method [ 4 ] .
Jeong et al. [59] describe an OBDD-based approach for solving the 0-1 pro
gramming problems. This approach does not, however, use OBDDs for integer re
lated operations such as conversion from linear inequality form of constraints into
Boolean functions and optimization of nonbinary goal functions. Consequently,
the caching of computation results is limited to only Boolean operations (i.e., for
constraint conjunction).
This chapter presents an approach for solving the ILP by combining benefits
of the EVBDD data structure (in term s of subgraph sharing and caching of com
putation results) with the state-of-the-art ILP solving techniques. The approach
uses a minimization operator in EVBDD which computes the optim al solution to a
given goal function subject to a constraint function. In addition, the construction
83
and conjunction of constraints in terms of EVBDDs are carried out in a divide and
conquer manner in order to manage the space complexity.
5.1 B ack grou n d
An ILP problem can be formulated as follows:
n
minimize c,xt,
j=i
n
subject to ^ aijXi < bj, 1 < j < m,
i= i
Xi integer.
The first equation is referred as the goal function and the second equation is re
ferred as constraint functions. It is assumed that the problem to be solved is a
minimization problem. A maximization problem can be converted to a minimiza
tion problem by changing the sign of coefficients in the goal function.
There are three classes of algorithms for solving ILP problems [93]. The first
class is known as the branch-and-bound m ethod [64, 31, 76]. This m ethod usually
starts with an optimum continuous LP solution which forms the first node of a
search tree. If the initial solution satisfies the integer constraints, it is the optim um
solution and the procedure is term inated. Otherwise, we split on variable x (with
value x* from the initial solution) and create two new subproblems: one with
the additional constraint x < [a;*J and the other with the additional constraint
x > [a:*J + 1. Each subproblem is then solved using the LP methods, e.g., the
simplex m ethod [32] or the interior point m ethod [60]. A subproblem is pruned if
there are no feasible solutions, the feasible solution is inferior to the best one found,
or all variables satisfy the integer constraints. In the last case, the feasible solution
becomes the new best solution. The problem is solved when all subproblems are
processed. Most commercial programs use this approach [65].
84
The second class is known as the implicit enumeration technique which deals
with 0-1 programming [2, 3, 91]. Initially, all variables are free. Then, a sequence
of partial solutions is generated by successively fixing free variables, i.e., setting
free variables to 0 or 1. A completion of a partial solution is a solution obtained
by fixing all free variables in the partial solution. The algorithm ends when all
partial solutions are completions or are discarded. The procedure proceeds similar
to the branch-and-bound except that it solves a subproblem using the logical tests
instead of the LP. A logical test is carried out by inserting values corresponding
to a given (partial or complete) solution in the constraints. A complete solution is
feasible if it satisfies all constraints. A partial solution is pruned if it cannot reach
a feasible solution or could only produce an inferior feasible solution (compared
to the current best solution). One advantage of this approach is that we can use
partial order relations among variables to prune the solution space. For example,
if it is established th at x < y, then portions of the solution space which correspond
to x = 1 and y = 0 can be immediately pruned [11, 48].
In the early days, these two methods were considered to be sharply different.
The branch-and-bound m ethod is based on solving a linear program at every node
in the search space and uses a breadth first strategy. The implicit enumeration
m ethod is based on logical tests requiring only additions and comparisons and
employs a depth first strategy. However, successively versions of both approaches
have borrowed substantially from each other [3]. The two term s branch and bound
and implicit enumeration are now used interchangeably.
The third class is known as the cutting-plane m ethod [43, 44]. Here, the in
teger variable constraint is initially dropped and an optimum continuous variable
solution is obtained. The solution is then used to chop off the solution space while
ensuring that no feasible integer solutions are deleted. A new continuous solution
85
is computed in the reduced solution space and the process is repeated until the con
tinuous solution indeed becomes an integer solution. Due to the machine round-off
error, only the first few cuts are effective in reducing the solution space [93].
5.2 A M o d e l A lg o rith m
This section first shows a straightforward method to solve the ILP problem using
EVBDDs. It then describes how to improve this m ethod in this and the following
sections.
E x a m p le 5.2.1 For the sake of readability, flattened EVBDDs (see Sec. 2.3.1) are
used in this example.
The following is a 0-1 ILP problem:
minimize 3a: -f Ay,
subject to 6a; -f Ay < 8, (1)
3x —2y < 1, (2)
€ {0, 1}-
We first construct an EVBDD for the goal as shown in Fig. 5.1 (a). We then
construct the constraints. The left hand side of constraint (1) represented by
an EVBDD is shown in Fig. 5.1 (b). After the relational operator < has been
applied on constraint (1), the resulting EVBDD is shown in Fig. 5.1 (c). Similarly,
EVBDDs for constraint (2) are shown in Fig. 5.1 (d) and (e). The conjunction of
two constraints, Fig. 5.1 (c) and (e), results in the EVBDD in Fig. 5.1 (f) which
represents the solution space of this problem. A feasible solution corresponds to a
path from the root to 1.
We then project the constraint function c onto the goal function g such th at for
a given input assignment X , if c(X) = 1 (feasible) then p(X) = g(X); otherwise
p(X) = infeasiblejvalue. For minimization problems, the infeasiblejvalue is any
value which is greater than the maximum of g, and for maximization problems,
86
1 1 1 0 3 4 0 7 0
10 6 4
(a) (b) (c)
0 1
1
1
1 0 1 0
0
3 -2 1
(d) (e) (0
0
8 4 8
(g )
Figure 5.1: A simple example (using flattened EVBDDs and OBDDs).
the infeasiblejvalue is any value which is smaller than the m inimum of g. This
example uses 8 as the infeasiblejvalue. Thus, in Fig. 5.1 (g), the two leftmost
term inal values have been replaced by value 8. The last step in solving the above
ILP problem is to find the minimum in Fig. 5.1 (g) which is 0. □
The above approach has three problems:
1. Converting a constraint from inequality form to a Boolean function may
require exponential number of nodes;
2. Even if all constraints can be constructed without using excessive amounts of
memory, conjoining them altogether at once may create too big an EVBDD;
and
3. The operator projection is useful when we want to find all optim al solu
tions. However, in many situations, we are interested in finding any optimal
87
solution. Thus, full construction of the final EVBDD (e.g., Fig. 5.1 (g)) is
unnecessary.
The remainder of this section will show how to overcome the first two problems
by divide and conquer methods, and the next section will present an operator
minimize which combines the benefits of computation sharing and branch-and-
bound techniques to compute any optimal solution.
Every constraint is converted to the form A X — b < 0. Thus, it only need
one operator leqO (Sec. 2.3.3) to perform the conversion. A X b is converted to
—A X + 6 < 0; and A X = 6 is converted to two constraints A X — b < 0 and
—A X + 6 < 0.
Initially, every constraint is an EVBDD representing the left hand side of an
inequality (i.e., A X — b) which requires n nonterm inal nodes for an n-variable
function. FGILP provides users with an n su p p param eter such that only if a
constraint has less than n su p p supporting (dependent) variables, then it will be
converted to a Boolean function. FGILP allows users to set another param eter
c s iz e to control the size of EVBDDs. Only if constraints, in Boolean function
form, are smaller in size than this param eter, they will be conjoined.
Param eters n su p p and c s iz e provide two advantages. First, they provide
FGILP with a space-time tradeoff capability. The more memory FGILP has, the
faster it runs. Second, combined with the branch-and-bound technique, some
subproblems may be pruned before the conversion to the Boolean functions or the
conjunction of constraints are carried out.
W hen there is only one constraint and it is in Boolean form, then the problem
is solved through m inim ize. Otherwise, the problem is divided into two subprob
lems and is solved recursively. Since both the goal and constraint functions are
represented by EVBDDs. The new goal and constraint functions for the first sub
problem are the left children of the root nodes of the current goal and constraints.
88
ilpsninimize(goal, const, lower Jbound, upper-bound, n su pp, c size )
{
1 if (max(goal) < lower-bound) return;
2 if (min(goal) > upper-bound) return;
3 if (3c € const such that m inim i ze(goal, c, upper .bound) = = 0) return;
4 new-const = conjunction-Const(const, csize);
5 if (new-const has only one element and is in Boolean form) {
6 (void) m inim i ze(goal, newsonst, upper-bound)',
7 }
8 else {
9 ((goali,new-consti), (goal-r,new-constr)) =
divide-problem(goal, newjconst, nsupp)',
10 ilp-minimize(goali, newsonsti, lower-bound, upper-bound, nsupp, csize)',
11 ilpjminimize(goalr, new sonstT, lower -bound, upper-bound, n su pp, csize);
12 }
}
Figure 5.2: Pseudo code for ilp-minimize.
Similarly, the new goal and constraint functions for the second subproblem are the
right children of the root nodes of the current goal and constraints.
The main algorithm, ilp-minimize, employs a branch-and-bound technique as
shown in Fig. 5.2. In addition to goal and constraint functions, nsupp , and csize,
there are two param eters which are used as bounding condition: Lower bound is
either given by the user or computed through linear relaxation or Lagrangian
relaxation methods; Upper bound represents the best feasible solution found so far.
The initial value of the upper bound is the maximum of the goal function plus 1.
If the maximum of goal function is less than the lower bound or the minimum of
goal function is greater than or equal to the upper bound, the problem is pruned.
Furthermore, if there exists a constraint whose minimum feasible solution is greater
than or equal to the current best solution (upper bound), then again the problem
is pruned.
89
( a ) 0 > )
( c )
z
w _
z
1 0
1 a
A A
1 o o
( d ) ( < = ) (0
Figure 5.3: An example for conjoining constraints.
E x a m p le 5.2.2 We want to solve the following problem:
minimize —Ax 4- 5y + z 4- 2w,
subject to 3x + 2y — Az — w < 0,
2x + y + 3z — Aw < 0,
x ,y,z,w € {0,1}.
1. The initial goal and constraint EVBDDs are shown in Fig. 5.3 (a). Suppose
both param eters n su p p and c s iz e are set to 4.
2. Since the number of supporting variables in the constraint EVBDDs is not
less than A, we divide the problem into two subproblems: one with x — 1
(Fig. 5.3 (b)) and the other with x — 0 (Fig. 5.3 (c)). The final solution is
the minimum of solutions to these two subproblems.
90
3. Next, we want to solve the subproblem with x = 1. Since the number of
supporting variables in constraint EVBDDs is smaller than n su p p , we convert
the constraint EVBDDs into Boolean functions by carrying out operation leqO
(Fig. 5.3 (d)).
4. Since the size of constraint EVBDDs are not less than c size , we divide the
problem into two subproblems: one with y = 1 (Fig. 5.3 (e)) and the other
with y = 0 (Fig. 5.3 (f)).
5. Now, we want to solve the subproblem with y = 1. Since the size of both
constraint EVBDDs are less than c size , we conjoin them together and then
solve this subproblem using the minimize operator (Sec. 5.3).
6. The remaining subproblems are solved in the same way. Note that the so
lution found from a subproblem can be used as an upper bound for the
subproblems which follow. □
5.3 T h e O p erator minimize
Operator minimize is similar to the apply operator with one additional param eter
b. Given a goal function g, a constraint function c, and an upper bound b, minimize
returns 1 if it finds a minimum feasible solution v < b of g subject to c; otherwise,
minimize returns 0. If v is found, b is replaced by v, otherwise, b is unchanged.
Note that when m inim ize returns 0, it does not imply that there are no feasible
solutions with respect to g and c. This is because m inim ize only searches for
feasible solutions that are smaller than b. Those feasible solutions which are greater
than or equal to b are pruned because of the branch and bound procedure.
The param eter b serves two purposes: it increases the hit ratio for computation
caching and is a bounding condition for pruning the problem space. To achieve
the first goal, an entry of the computed table used by minimize has the form
91
(g, c, (6, v)) where v is set to the minimum of g which satisfies c and is less than b.
If there is no feasible solution (with respect to g and c) which is less than b, then
v is set to b.
The following pseudo code implements minimize. Lines 1-8 test for term inal
conditions. In line 1, if the constraint function is the constant function 0, there
is no feasible solution. In line 2, if the minimum of the goal function is greater
than or equal to the current best solution, the whole process is pruned. If the goal
function is a constant function, it must be less than bound; otherwise, the test in
line 2 would have been true. Thus, a new minimum is found in line 3. In line 6, if
the constraint function is constant 1, then the minimum of the goal function is the
new optimum. Again, this must be true, otherwise, the condition tested in line 2
would have been true.
Lines 9-17 perform the table lookup operation. If the lookup succeeds, no
further computation is required; otherwise, we traverse down the graph in lines
19-26 in the same way as apply. Since minimize satisfies the additive property
(Sec. 2.3.2), we subtract cg from bound to obtain a new local bound {local-bound)
in line 9. cg will be added back to bound in lines 13 or 32 if a new solution is found.
Suppose we want to compute the minimum of g subject to c w ith current local
upper bound local-bound. We look up the computed table with key (g,c). If
an entry (< 7,c, {entry .bound, entry .value)) is found, then there are the following
possibilities:
1. entry .value < entry .bound, i.e., a smaller value v was previously found with
respect to g, c, and entry.bound (i.e., the minimization of g with respect to
c has been solved and the result is entry.value).
(a) If entry.value < local-bound, then entry .value is the solution we wanted.
(b) Otherwise, the best we can find under g and c is entry .value which is
inferior to local-bound, so we return with no success.
92
2. entry .bound = entry.value, i.e., there was no feasible solution with respect
to g, c, and entry.bound (i.e., there is no stored result for the minimization
of g with respect to c and entry .bound).
(a) If local-bound < entry.bound, then we cannot possibly find a solution
better than entry .bound for g under c. Therefore, we return with no
success.
(b) Otherwise, no conclusion can be drawn and further computation is re
quired. Although there is no better feasible solution than entry.bound,
it does not imply that there will be no better solution than local-bound.
In cases l.b and 2.a pruning takes place (also computation caching), in case l.a,
com putation caching is a success, while in case 2.b both operations fail. Note that
there is no need for updating an entry (of the computed table) except in case 2.b.
In lines 25-30, the branch whose minimum value is smaller is traversed first since
this increases chances for pruning the other branch. Finally, we update computed
table and return the computed results in lines 31-39.
93
minimize{(cg, g ) , (cC ) c ), bound)
{
1 if ({cc, c) = = (0 , 0 )) return 0 ;
2 if (ram((ca,g )) > bound) return 0 ;
3 if ((c„g) = = (^ ,0)) {
4 bound = cg\
5 return 1; }
6 if « C c , c ) = = ( 1 , 0 )) {
7 bound — min((cg,g));
8 return 1 ; }
9 local-bound = bound — c3;
1 0 if (comp-tabteJookup((0 ,g), (cCic), entry)) {
1 1 if [entry.value < entry.bound) {
1 2 if {entry.value < local-bound) {
13 bound = entry, value + c .g\
14 return 1; }
15 else return 0; }
16 else {
17 if (local-bound < entry .bound) return 0 ; } }
18 entry.bound = local-bound;
19 (cgi, gi) = (value(g),childi(g));
2 0 (c 3r,gr) = (0 ,childr(g));
2 1 if (index(variable(c)) < index(variable(g ))) {
2 2 (cC (, ci) = (cc + ua/ue(c), childi(c));
23 (cC r ,c r) — (cc, child? (c )), }
24 else { *3 ? * 4 ) with respect to the
bound set {*0, * 1 , * 2 } and the free set {* 3, * 4 } are shown in Fig. 6.1 (a) and (b) re
spectively. In the OBDD representation, c u tset( f, {*0 , * 1 , * 2 }) = { a jb ,c } . Nodes
a, b , and c correspond to distinct columns 1100, 1010, and 1011 respectively. Since
there are three distinct columns / is not simply decomposable under the bound
set {*0 , * 1 , * 2 } and the free set {*3 5 * 4 }. □
When bound variables are on the top of OBDDs, the computation of cutjsets
is straightforward. The following procedure assumes that bound variables B are
already on the top of OBDDs. The tim e complexity of computing cut-sets depends
on the size of OBDDs.
c u tset(v, B )
{
if (m de*(v) > index(last(B))) return({ v });
else return( cutset(childi('v), B) U cutset(childr(v), B ) );
}
102
0
1
I 1
X, X,
2 2 2
XS
1 0 1 0 1 0 0 0
0 1 0 1 0 1 1 1
01 0 0 0 0 01
a
(a)
(b )
Figure 6.1: A function represented in (a) OBDD and (b) decomposition chart.
To move a bound variable x to the top of an OBDD, we carry out new-obdd(x,
fx, fx) where fx and fx are the cofactor of / with respect to x and x respectively.
In the worst case, both fx and fx have about the same size as that of f. Thus,
moving a variable to the top may double the size of an OBDD. To move bound
variables to the top is therefore practical only for small size of bound sets. An
algorithm for computing the cutjset without moving the bound variables to the
top will be presented in Sec. 6.3.
It is clear that the computation of cut_sets of all 2n bound sets is very expensive.
However, in practical applications, we need compute the cut_sets of C£ bound sets
where k is a small number such as 4 or 5. The time complexity of computing
the cut_sets of n choose k bound sets is then 0 (n km ) and the space complexity is
0(2km ) where m is the size of an OBDD.
The following algorithm shows how to perform the disjunctive decomposition
• • • > >£n— l ) — f (flr o ( ‘Eo* • • • > ■£»—l ) ? • • • j 9 j —1 (a :o , • • • 5 ® i —1 ) J •£*J • • • J ® n —1 )
directly on an OBDD.
103
A lg o rith m decompose (pseudo code decompose):
Given a function / represented in an OBDD Vf and a bound set B, a disjunctive
decomposition with respect to B is carried out in the following steps:
1. Compute the cut-set with respect to B. Let cu<_sef(v, B ) = {uo, • •., uic.j}.
2. Encode each node in the cut_set by [log2 A f| = j bits (Fig. 6.2 (a)). Let the
encoding of u q be q.
3. Construct V f< to represent function / ':
Replace the top part of Vf by a new set of variables g0, . . . , gj-i such that
eva/(vf<, q) = u q for 0 < q < k — 1 , eval(vp, q) — Uk_i for k — 1 < q < 2 J
(Fig. 6.2 (b) and pseudo code decomp-f).
4. Construct v gp’s to represent gp’s, 0 < p < j:
Replace each node u with encoding b0, . . . , bj_x in the cut_set by term inal
node bp (Fig. 6.2 (c) and pseudo code decomp-g). For example, in Fig. 6.2
(c) Ui is replaced by terminal node 1 in the construction of v g. and by
J •
term inal node 0 in the construction of other v gp’s.
The idea behind Algorithm decompose is the following: For any input pattern
m in the bound set, the evaluation of m in function / will result at a node in the
cut_set with encoding e. The evaluation of m on these gp functions will produce
the function values e. Then, the evaluation of e in function / ' will also end at the
same node in the cut-set. Thus, the composition of / ' and gp’s is equivalent to
/ . If k < 2J, then not every jr-bit pattern is used for the encoding of the cut_set.
Function gp s can never generate those function values which correspond to the
patterns not used for encoding, thus we can assign arbitrary node to these pattern
in function / '. In step 4, we assign them to the last node in the cut-set (u k -i)-
Alternatively, we can assign don’t-cares instead.
104
A ?
i -1
6
k -l U 1 U 0
( a )
(b)
i -1
« k -l « ! U 0
i-1
U U
u o k -l
(c)
Figure 6.2: Disjunctive decomposition.
In step 2 of Algorithm decompose, we use an arbitrary encoding which is not
unique. Different encodings will result in different decompositions. Different en
coding strategies can be used for different applications. For example, in the map
ping of G-functions to fc-input LUT FPGAs where a fc-input LUT can implement any
Boolean function of up to k variables, any encoding strategy would be the same if
the bound-set size is k.
decompose(vj, cutset) /* cutset = { u q , .
{
Vf/ = decomp-f (cutset, {yj- 1, ..., j/o});
for (p = 0 ;p < j;p + + )
v gp = decomp.giy j , cutset, p);
return V// and v 3p’s;
}
105
decomp-f (cutset, ids)
cutset: an array of OBDD nodes with 2J _ 1 < length(cutset) < 2J
return: an OBDD V// with variables y0, . . . , . . . , xn^\
{
p trJd = 0 ;
while (length(cutset) > 1 ) { /* do until cutset becomes a root node * /
id = ids\ptrJ,d + +];
p = 0 ; /* pointer to cutset */
p tr = 0 ; /* pointer to new set */
while (p < length(cutset)) {
if (p —= length(cutsei) — 1 ) { /* the last element of cutset */
newset\ptr + + ] = cutset[p\', /* just move it to newset */
p + + ; /* p is increased by 1 */
}
else { /* create a new node with new variable ym */
newset[ptr + + ] = newJbdd(id, cutset[p + 1 ], cutset\p]);
p-j- = 2 ; /* p is increased by 2 */
}
}
for (q = 0 ; q < ptr\q + + ) /* move nodes from newset to cutset */
cutset[q] = newset[q];
}
return(cutsef[0]); /* cuisei[0] contains Vj> */
}
106
decomp-g{y, cutset, p)
v: an OBDD
cutset: an array of OBDD nodes with 2J _ 1 < length(cutset) <
p: an integer between 0 and j — 1
return: v gp
{
for (q = 0 ; q < length(cutset); q + + ) {
v q = cutset[q];
if (bit(p, 9 ) = = 0 ) /* pth bit from right of q */
v = replace-node(v, v q, 0 ); /* replace v q in v by 0 */
else v = replace-node(v, v q, 1 ); /* replace v q in v by 1 */
}
return v; /* as v gp */
}
E x a m p le 6.1.2 As an example of how decompose works, consider the OBDDs
shown in Fig. 6.3. Since X 4-node in f has encoding 01, it has been replaced by
terminal nodes 0 and 1 in go and g i respectively. The evaluation of x 0 — 1 ,
x\ = 0, and # 2 = 1 in f ends at ^4 -node in the cutjset. The evaluation of the same
pattern 1 0 1 in g o and g i produce function values 0 and 1 for new variables go and
g\. Then, the evaluation of 01 in f also ends at the same a ;4-node.
Because there is no encoding 11 in the cut_set, variables go and g\ can never
be 11. We can assign arbitrary value for this pattern. In this example, we assign
the left x3-node so that the left #i-node can be reduced in f'. □
L e m m a 6.1.1 Given an OBDD Vf with variable ordering x0 < ... < £n- i rep
resenting f{ x o , . . . , x n_i), a bound set B = {a?o,... the c u tse t(v f, B ) =
{1 1 0 , . . . , U k _ i} , and algorithm decompose returning OBDDs Vf/, v g(), . . . , vgj _ l 5
107
0 0
1 0 L
o
i
00
10,
o
1
Figure 6.3: An example of disjunctive decomposition.
then
f (X0 , • • • r 3'n— l ) — f (9 o(xo, • • • ) % i— 1 ), • • • , Qj—1 (•^ ' 0 ? • * • » •£ » — 1 ) j X ! % 1 • • • » 3'n— 1 )
where / ' , g0, . . . , gj-% are the functions denoted by Vf», vgQ,..., v g^ 1, respectively.
Proof: Consider the behavior of an input pattern (bo, ..., & ,•_ i) on Vf, V f< and Vgp’s.
Suppose u q with encoding q is the node we reach in Vf using the input pattern, that
is, eval(vf, (b0, ..., 6 ,_i)) = u q, where u q = f(b0, ..., 6*_i, ..., Since u q
has been replaced by the pth bit of q in v gp, eua/(vgp, (bo, ..., 6,-_i)) = bqp, that is,
gp(bo, ..., bi-1 ) = bqp. Because of the way we construct Vf», eua/(vf», (bqo, ..., f e 9i_x))
— uq, that is, f (bqQ , . . . , b q , Xj, . . . , Xji— l ) Uq / (^0 j • • • ? ^i-l) ■ j *£n —1 )*
Thus, _ / " (go(bo, ..., ..., ^t— 1)> • • •? ®n— 1) = f(bo, ...,
..., a ;n_ i), for any input pattern in the bound set. □
6.2 N o n d isju n c tiv e D e c o m p o sitio n
Before describing how to perform nondisjunctive decomposition based on the OBDD
representation, the concept of c u tset is extended in the following definition.
108
D efin itio n 6 .2 . 1 Let R = {xo, • • • S = {xs, x;_i}, and T = {x»,
xn_x}, 0 < s < i < n. Given an OBDD v representing f ( x 0, . . . , Xn-i), a bound set
R U S, and a free set S U T , we define
c u tse t jnd(v, R, S, p) = {eval(w,p) | w £ c u ts e t (v, f?)},
where 0 , 0). The following presents a pseudo code for computing cu tsetjn d and an
example of it.
c u tse t jnd(v, R, S ,p ) /* 0 < p < 2 ^ * /
{
if (m dex(v) < index(head(S)))
Teturn(cutset-nd(childi(v), R , S ,p ) U cutset-nd(childr(-v), R, S , p ));
else if (index(head(S)) < index(v) < index {last (S'))) {
q _ 2in d ex(la st(S ))—in d e x (v ).
if (q < p) /* then traverse down through left edge */
return (cu tset jnd{childi{v), R ,S ,p — q));
else Te%\xxn(cutset-nd(childr(y), R, S ,p ));
}
else return({v});
}
E x a m p le 6.2.1 The OBDD in Figure 6.1 (a) has
cutsetjnd(f, {xo,xi}, {x2 } ,0 ) = {a, b},
c u tsetjn d (f, {xo,Xi}^ {x2} ,l) = {b ,c },
cutset.nd(f, {x0}, {xj, x 2}, 0 ) = {a},
cutset.nd{f, {xo}, {xi, x 2}, 1 ) = {b, c},
cutset.nd({, {xo}, {xi, x2}, 2 ) = {a, b}, and
cu tset.n d(f, {xo}, {xi, x2}, 3) = {b, c}. □
109
A lg o rith m decompjnd (pseudo code decompjnd):
Given a function / represented in an OBDD Vf, a bound set {xo, • • • ? x si • • • ?
and a free set {xs, . . . , Xi_ l 5 . . . , xn_ i), a nondisjunctive decomposition with respect
to the given bound set and free set is carried out in the following steps:
1. Compute cutsetjnd(vf, R, S,r) for 0 < r < 2 ^ where R = {xo,. . . , xs_i}
and S = {xs, . . . , Xj_i} (Fig. 6.4 (a)). Let c u tse t jnd(vf, R , S, r) = {urio,
• • * ) u r> i}, m ax{| c u tse t jnd(vf, R , S, r) |} = k, and j = [log2 A :].
2. Construct Vf/ to represent function f in two steps (Fig. 6.4 (b) and pseudo
code decomp-f .nd):
(a) Construct v q, 0 < q < k, such that eua/(vq, r) = u q)f where u qiI
is the qth element in c u tset jnd(vf , R, S\ r) or the last element if q >
| cutset-nd(vf, R, S,r) |.
(b) Construct Vf/ such th at eval(vfr,q) = v q for 0 < q < k — 1 and
eval(vf>,q) = Vk-i for k — 1 < q < 2 L
3. Construct v gp’s to represent s for 0 r (qth node of c u ts e t_nd(vf, R, S, r)) from Vf by the
term inal node whose value is bq p where bq p is the pth bit from the least sig
nificant bit of integer q.
Note th at, a node u may be the tth element of c u tset jnd(vf, R, S, ri) and the
j tiL element of c u tsetjn d (v f, R, 5, r 2 ) which requires different encodings for u. This
will not cause a problem because we can first duplicate the node u and then assign
each copy a different encoding. An alternative statem ent is that if paths p\ and p 2
both end at node u and require different encodings b\ and 6 2> then we let pi end
at term inal node bi and p2 end at term inal node b 2.
110
/V o
(c)
Figure 6.4: Nondisjunctive decomposition.
decompjnd{vf, {xo, • • •, {xs, . . . ,x,_i})
{
for (r = 0 ; r < 2 * '_*;r + + )
cutsetndr = cut-3etjnd(vf, {xo, • • - ? } > {x a, . . . , r)
k = m ax{| cutsetndr |};
j = [log2 k] ;
V f< = decomp.f jnd({cutsetnd!s}, { x ,_ i,. . . , xs}, {yj- 1 ,.. •, yo});
for (p = 0 ;p < j',p + +)
vgp = decomp-gjnd(vf, {cutsetndfs},p);
return Vjv and Vgp ’s;
}
111
decomp-.f jnd(cutsetnds, idx, idy)
cutsetnds :{cutsetndr | 0 < r < 2,- s } with max{\ cutsetndr |} = i f c ; and
[log2 A f| = j;
cutsetndg> r :qth element of cutsetndT, or the last element of cutsetndr
if q > | cutsetndr |;
%dx « {xt— ij ■ • • j ,
idy : { y j- i, ..., y0};
return: an OBDD Vfi with variables yo, ..., y j- 1, x8, ..., , x n_i;
{
for (q = 0; q < fc ; q + + )
v q = decomp-f({cutsetndqtr | 0 < r < 2*~s},idx)]
V f< = decomp-f({vq | 0 < q < fc},edy);
return V/<;
}
decomp-g~nd(vf, cutsetnds, p)
return: v gp;
{
for (r = 0 ; r < 2 ‘-1 ; r + + ) {
if (eua/(vf, r) = = cutsetndqtP)
let er;a/(vgp ,r) = bit(q,p);
}
return v 3p;
}
E x a m p le 6.2.2 One possible nondisjunctive decomposition of the OBDD in Fig. 6.1
(a) with respect to the bound set {xo, x\, x2} and the free set {x2 ,X3 , x4} is
shown in Fig. 6.5. In this decomposition, we use the following coding: {a =
112
1 0
10 0 1 0 1
c
1.1
0,0
1.0
o
1
Figure 6.5: An example of nondisjunctive decomposition.
uo.o,b = u 0 ,i} = cu tset jnd(vf, {xo, Xi}, {^ 2 }? 0 ) and {c = 1 1 1,1 , b = Ui,o} =
c u tse t jnd(vf, {xo, Xi}, {* 2 }) 1 )- n
L em m a 6 .2 .1 Given an OBDD Vf with variable ordering x0, ..., representing
/ ( x 0, • • •, Xn-\), and k = max{ | c u tse t aid (v f, {x 0, ..., x s_ i}, {xs, ..., x,-_x}, r) |
0 < r < 2t-s }, 2J - 1 < k < 2 \ the algorithm decomp-nd returns j + 1 OBDDs
Vf/,vg0, ..., Vgj^j such that /(x0, . . = f(g o (x 0, - • •, -.., g j-i(x0, ..
x ,_ i), x s_ i, ..., x,-_ 1 , ..., x n-\) where f ,go, • • • ,gj-i are the functions denoted by
v f'> v g0’ • • • » v gj_i’ respectively.
Proof: Consider the behavior of an input pattern (b0,..., bs, ..., 6,_i) on Vf, V f< and
Vgp’s. Let eua/(vf, {b0,..., bs, ..., 6,_i)) = uq>r, where r = 2% ~s~1 bs + . . . -f 2°6j_i.
Since u q > r has been replaced by b qp in v gp, we have eua/(vgp, (bo, ..., bs, ...,
&i-i)) = bqp. Then from eval(vf>, (bqo, ... ,bqj_,)) = v q and eua/(vq,r ) = u q > r =
ewa/(vq, (6 S, ..., fej_x)), we have
eval(vfi, (bqo,..., bqj_l t bs, ..., = uq,r = et>a/(vf , (b0, ... ,bs, . . . , 6;_i}). □
113
6.3 C ut_set In P la c e
This section considers only disjunctive decomposition. It first presents an algo
rithm for computing an encoded decomposition chart from the tru th table of a
function. It then shows a similar algorithm which computes cut_sets without mov
ing bound variables to the top of OBDDs.
D efin itio n 6.3.1 Given a function / with n variables and a bound set B with
size i < n, the encoded decomposition chart of / with respect to B is a vector c
with length 2 * where each distinct element of c corresponds to a distinct column
of the decomposition chart of / .
D e fin itio n 6.3.2 Operator encode is defined as follows:
encode((v0 > 0 , . . . , Uo^-i)? ■ ■ ■ , (um-i,o, • • •, vm_1 > 2<_i) = (vm,o, • • • ,vmiv -i)
where vm > Q = 0 , and vm iP = q if {vQ • • • i^m -l,2 *-l)-
E x a m p le 6.3.1 The decomposition chart shown in Fig. 6 . 6 (a) has Xi and xj as
the free set. We show how to convert the decomposition chart into an encoded
decomposition chart one variable at a time. W ith respect to variable a:,-, we encode
the first two rows and the last two rows in Fig. 6 . 6 (a) by:
encode(( 1 , 1 , 1 , 0 , 1 , 1 , 1 , 0 ), (1 , 1 , 1 , 0 , 1 , 0 , 1 , 0 )) and
encode((0 , 0 , 1 , 1 , 0 , 0 , 1 , 0 ), (0 , 0 , 1 , 0 , 1 , 0 , 1 , 1 )), respectively.
The result is shown in Fig. 6 . 6 (b). W ith respect to variable xj, we carry out
encode((0,0 ,0 ,1 ,0 ,2 ,0 ,1 ), (0 ,0 ,1 ,2 ,3 ,0 ,1 ,3 )) and derive the encoded decomposi
tion chart as shown in Fig. 6 . 6 (c). □
D efin itio n 6.3.3 An encoded decomposition vector (edv) is a vector
([eo.o, • • •, eo,2>-iL • • •» [e2*-i,0j • • • > e2*-i,2J|- i ] )
where j > 0, i > 0, ek,i is an integer. Each element of an edv, [e^o,. . . , is
called an encoded decomposition column (edc).
114
X
I
X
i
(a) (c)
Figure 6 .6 : An example of coded decomposition chart.
Pseudo code gen^edc constructs the encoded decomposition chart of a given
function and bound set as described before. Initially, we have an edv containing
only one edc which is the tru th table representation of the given function (line 1 ).
Each variable, from x0 to x„_i (line 2), is processed in the following way: If x p is
in the bound set, we use include to double the number of edc’s by breaking each
edc into two edc’s such th at each new edc corresponds to either xp — 0 or xp — 1
(line 3); otherwise, we use exclude to cut the size of each edc and to perform the
encode operation in the same way as in Ex. 6.3.1 (line 4). After all variables have
been processed, the number of edc’s will be 2 * where i is the size of the bound
set (due to the calling of include i times), and each edc contains only one element
(due to the calling of include and exclude n times in total). We then flatten the
edv to get the encoded decomposition chart.
1 1 1 0 1 1 1 0
1 1 1 0 1 0 1 0
0 0 110 0 10
0 0 10 10 11
]
X.
0001
0 0 12
0 2 01
3 0 13
(b )
0 0 1 2 3 4 15
115
gen-edc(f, B)
f : a Boolean function with n variables represented by the truth table form as
[m0, ..., m 2n_ 1] where mo, m i , , m2»-1 - 1 are the minterms correspond
to xq = 0 and m0, m2, ..., m2n_2 are the minterms correspond to xn- i = 0;
B : a bound set;
{
1 ed u = ( [ m o , . . . , m 2n_i]);
2 for (p = = 0; p + + ; p < n) {
3 if (a:,, € B) edv = include(edv);
4 else edv = exc/ude(edt>);
5 }
6 return(//a_i],...,
[e2‘-l,0j • • • 5 e2*-l,2>— 1 — 1 ]> [e2 * — 1 ,2 -» — 15 • • • > e2'-l,2>-l]));
}
exclude(([e0)o , .. •, e 0> 2> _ i], .. •, [e2<_it0, • • •, e2i— i,2>_i]))
{
(d0)o, • • •, d0> 2i - i _ i , dli0, . . . , d 1) 2j - i _ i , .. •, d 2i_lj0, . . . , d 2i_ ij2J- i _ i ) =
encode((eo,o, • • •, e0)2>-i_i, ei,o,. . . , • • •, e2i_1)0, • • •, e 2i_li2j-i_i),
(eo,2i - i , .. •, e0 )2J-i, eii2>-i,..., e1> 2i_l5..., e2i_1)2>-i,..., e2i_ii2J_i));
return(([do,o, • • •, doi2> -i_ i], [d i,o ,. . . , d i i2j - i _ i ] , . . . , [d2; _ i (o, ■ • •, d 2i_i, 2>— 1— i]))?
}
116
flatten(([e0],.. -, [e2i-i]))
{
return((e0, . . . , e2i_i));
}
E x a m p le 6.3.2 The application of gerue.dc to the function in Ex. 6.1.1 with
bound set {^o? x 2, £4 } is summarized below:
1. Initially, we have {[1100 1011 1100 1010 1100 1010 1010 1011]).
2. Since xq is in the bound set, we execute bound-V and have
{[1100 1011 1100 1010], [1100 1010 1010 1011]).
3. After applying freejv on x\, we have
Vo : 1100 1011 1100 1010
Vi : 1100 1010 1010 1011 = ► {[0011 0102], [0231 0103]).
C : 0011 0102 0231 0103
4. After processing x 2, we have {[0011], [0102], [0231], [0103]).
5. The computation of freejv on x% is:
V o : 00 01 02 01
V x : 11 02 31 03 {[00], [12], [34], [15]).
C : 00 12 34 15
6. After the processing of x4 and fla tte n , we have the encoded decomposi
tion chart {0,0,1,2,3,4,1,5) which implies that there are 6 different distinct
columns in the decomposition chart as shown in Fig. 6.7.
117
X 0
1 .........1
1 1
x 2 X 2
1 1 1 I
X 4 x 4 X 4 X 4
1110 1110
x ,
1110 10 10
0 0110 0 10
X 1
0 010 10 11
0 0 1 2 3 4 15
Figure 6.7: The decomposition chart with respect bound set {a:0, x% , x4}.
The following pseudo code c u tset Jp is the OBDD version of gen-edc.
c u tse t spinode-vector, B , p)
{
1 if (p > index(last{B))) return {node-vector)]
2 if (xp € B ) Teturn(includeu>bdd(node-vector, B,p));
3 else TetnTn(excludesbdd(node-vector, B,p))]
}
includejobdd((vq, ...
{
Teturn(cutsetJp({r-ckild(vQ,p), l.child(vo,p),... ,r-child{v2\_x,p),
l-child(y2i_l t p)), B ,p + 1));
}
118
e
h
i o
X X
2 I
c d
f h
f 9
1 1 1 1
* 4
a X 4
1 0
0 1
0 1
1 0
0 1
0 0
* 5
b
XA
1 1
1 0
1 1
0 0
X
4
0 1 1 1
X 1
0 0 0 1
1 a
9 h
A s
d e
( a ) 0>)
Figure 6.8: An example for cut-set in place.
excludejobdd((vo, ..., v 2i_ 1 ),5,p)
{
TetuTn(encode(cutset Jp((r-child(vo,p),..., rjchild{v2\_x,p)), B ,p + 1),
cutset-ip((l-child(vo,p) ,..., ljchild{v^\
}
E x a m p le 6.3.3 The execution of cutset-ip on the OBDD shown in Fig. 6.8 (a)
with bound set B = {a^, 2 2 } is summarized below:
initial: cutset Jp((v), B , 0),
p = 0: encode(cutsetJp({a), B , 1), cutset Jp((b), B , 1)),
p = 1 : encode(cutsetJp((c, d), B , 2), cutset-ip({d, e), B , 2)),
p = 2: encode(cutsetJp((f, h, f, g), B , 3), cutset Jp((f, g, g, h), B , 3)),
p = 3: encode(({, h, f , g), ( f, g, g, h ) ),
result: <0,1,2,3).
The decomposition chart is shown in Fig. 6.8 (b). □
119
6.4 C o m p u tin g C u t_sets for A ll P o ssib le B o u n d
S ets
The previous sections showed how to perform function decomposition directly on
OBDDs when a bound set is given. This section will show how to compute the
c u ts e ts for all bound sets of (single-output) Boolean functions using EVBDDs.
The m ethod is based on the encoding of columns as integers.
Initially, every variable is in the free set. For each variable xt, we perform the
following two operations:
1. include: include X{ in the bound set to derive a new cut-set, and
2. exclude: partially encode the columns such that distinct columns are given
unique codes and variable X{ is perm anently excluded from the bound set.
E xam ple 6.4.1 Fig. 6.9 (a) shows a decomposition chart where variable x is in
the free set and a,b, c, d, e, / , and g are Boolean values. To perform the include
operation, we move the two bottom rows to the left of the top two rows such that
x now is in the bound set (Fig. 6.9 (b)). To perform the exclude operation, we
encode bit vectors (c,a), (d, b), (g,e ), and (A ,/) as 2c -j- a, 2d + 6, 2g + e, and
2h + / , respectively (Fig. 6.9 (c)). The coded decomposition chart preserves the
distinctness of columns, that is, column (a, 6, c, d) is distinct from column (e, / , g, h)
if and only if column (2c + a ,2d + b) is distinct from column (2g + e,2h + f).
Furthermore, variable x is absent from the encoded decomposition chart and will
never be included in the bound set. □
Given an EVBDD v with the top variable Xi, the right and left children of v
correspond to the top and bottom halves of rows in the decomposition chart. Thus,
operations include and exclude in the EVBDD representation are carried out in the
following way:
120
X
[
b f
y
c g a c 2c+a 2g+e
c
g
d h b f
y
2d+b 2h+f
d h
y
2d+b 2c+a 2h+f 2g+e
(a) (b) (c)
Figure 6.9: Operations include and exclude in the decomposition chart.
7 ; u
C y )(7 ) (7)(F ^
d c b a h 9 f e h gf e d c b a
(a) and free set X where X is the set of input
variables. If i = n, then we reach the term inal case and n o d e set is the (encoded)
cut_set for bound set B (line 1); otherwise, we perform include and exclude opera
tions with respect to variable X{ (lines 2 and 3). We repeat the process for variable
121
xt+1 in lines 4 and 5. In line 6, the union of (6, fc)’s from lines 4 and 5 is returned.
Pseudo code include and exclude perform the include and exclude operations for
a set of EVBDD nodes.
c u ts e t s ll(n o d e s e t, B , i)
{
1 if (i = = n) return({{.B, | n o d eset |)});
2 in c s e t = include{nodeset, i)]
3 e x c se t = exclude(nodeset,«);
4 inc = c u tse t-a ll(in c se t, B U {xj}, i + 1);
5 exc = cu tsetu a ll(excset, B ,i + 1)',
6 return(m c U exc)]
}
include{nodeset, i)
{
1 new s e t = < f> ]
2 for each node u G n o d e set {
3 if (index(variable{u)) = = i)
4 n e w s e t = n e w s e t U {childi(u), childr(u)}]
5 else /* index(u) > i * /
6 n e w s e t — n e w s e t U {u};
7 }
8 return new set]
}
122
exclude(nodeset, i)
{
1 n e w s e t = 4 > \
2 for each node u £ n o d eset {
3 if (index(variable(u)) = = i)
4 n e w s e t = n e w s e t U {22’ x childi(\i) + childr(u)}]
5 else /* mdea:(u) > i * /
6 n e w s e t = n e w s e t U {22' x u + u};
7 }
8 return n e w s e t;
}
E x a m p le 6.4.3 Fig. 6.11 (a) shows a function represented by both a tru th table
and a flattened EVBDD. Initially, the bound set is empty. The application of
include and exclude with respect to variable xq are shown in Fig. 6.11 (b) and
(c), respectively. In Fig. 6.11 (b), the bound set is {a:o} and the cardinality of the
cut_set is 2; In Fig. 6.11 (c), the bound set is < j > with cut_set size 1.
The application of include and exclude on Fig. 6.11 (b) with respect to variable
Xi results in Fig. 6.12 (a) and (b) with bound sets {a:0, and {so} and cut_set
sizes 2 and 2, respectively. The application of include and exclude on Fig. 6.11 (c)
with respect to variable x\ results in Fig. 6.12 (c) and (d) with bound sets {^i}
and < f ) and cut_set sizes 2 and 1, respectively.
The application of include and exclude on Fig. 6.12 (b) with respect to variable
x 2 results in Fig. 6.13 (a) and (b) with bound sets {aro,aj2} and {#0 } and encoded
cut-sets {0,1, 5,4} and {5,12}, respectively. In Fig. 6.13, the top row shows the
encoded decomposition charts, the second row shows the encoded cut_sets, and the
third row shows the decomposition charts. The encodings used for the bottom row
in Fig. 6.13 (a) and (b) are 1 x rowl + 4 x row2 and 1 x row 1 + 2 x row2 + 4 x
row3 + 8 x row4, respectively. □
123
{
- [
(
1 0
0 1
1 1
0 0
e b
0 10 1 0 11 0
(b)
2
1
3
0
0 3 12
(C)
Figure 6.11: An example of the application of c u tset-a ll.
X X X
0 0 0
1 l 1 0 5 4
0 0 0 1
X p
0 1
e f
9
h
3 2
0 1
* i
* © © h
0 5 1 4
(b)
Figure 6.12: Example continued.
x 2) k
14 1
(d )
124
0 o
0 1 5 4 5 1 2
I ; I
X,
{0 ,1,5, 4 } (5 , 12}
0 1 1 0
0 0 1 1
I i
(a)
'•[
1 0
0 1
1 1
0 0
(b )
Figure 6.13: Example continued.
Since there are 2n different bound sets for an n variable function, the compu
tation of the c u ts e t for every bound set is very expensive. If we replace line 1 in
cut s e t sill by
1 if (level == n || | v a r s e t |< k) return({(I?, | n o d e set |)}),
then c u tse t-a ll becomes a routine for computing the cardinality of the cut_set
for every bound set whose size is less than or equal to k which is useful for the
technology mapping of £-input look-up table field programmable gate arrays [58].
A naive way to compute the c u ts e t for every bound set is to move bound vari
ables to the top of the EVBDD. Compared to this approach, the above approach
has the following advantages. First, it is well known that the size of OBDD (and
EVBDD) is very sensitive to the variable ordering (at least in many practical appli
cations [66]). Moving bound variables to the top will change the variable ordering
and hence may cause storage problems. The EVBDD-based method will not change
the variable ordering. Second, the number of variables in the direct variable ex
change approach is never reduced. In contrast, in EVBDD-based method, after the
include and exclude operations, the number of variables will be decreased by 1.
125
6.5 M u ltip le-O u tp u t D ec o m p o sitio n
Given a vector of Boolean functions / 0, . . . , f m - 1 on n variables, we can not extend
the concept of c u ts e t by taking the set union of the c u ts e ts for the individual
functions. To see this, consider the two extreme cases U S )1 c u tset(v{, 0) (bound
set size 1) and U S 1 c u ts e t(v i,n — 1) (bound set size n ). The cardinality of the
former might be greater than 2. This implies that more than two distinct functions
must be implemented by a single variable which is not possible. On the other hand,
the c u ts e t of the latter is always {0, 1}. This implies that m Boolean functions
could be implemented by only one output line which is again not possible. This is
because even when an OBDD node is shared by ith and j th functions, it should be
treated differently.
While a problem with finite domain can be solved by conversion to Boolean
functions, a problem related to multiple-output Boolean functions can also be
solved by interpreting them as the bit representation of an integer function. For
example, a multiple-output Boolean function ( /o ,. . . , / m- i) can be transformed to
an integer function F by F = 2Tn-1/o + . . . + 2 ° /m_i. Based on this formulation,
we show how to perform multiple-output decomposition using EVBDDs. We first
extend the definitions of function decomposition and cut_sets to EVBDD represen
tation. We then develop an EVBDD-based disjunctive decomposition algorithm.
D e fin itio n 6.5.1 A pseudo Boolean function f ( x o,..., z n- i) is said to be decom
posable under bound set {a:0, . . . , a \-i} and free set {x{,... £n-i} , 0 (go{xo,..., x,_i),... ,g j(xo,..., £»,..., x n- i ) such
that the number of inputs to f is smaller than that of / . If j equals 1, then it is
simply decomposable.
Note that since inputs to a pseudo Boolean function are Boolean variables,
function g ^s are Boolean functions. Here, we consider only disjunctive decompo
sition (the intersection of bound set and free set is empty).
126
d(x. a [x.
b (x
5 6 4 56 34 126
Figure 6.14: An example of cut_set in EVBDD.
D efin itio n 6.5.2 Given an EVBDD (c, v) representing f ( x 0, ... ,x n- i) with vari
able ordering x 0 < . . . < x n- \ and bound set B = {x0, ..., £,•}, we define
cutset-jev((c, v), B ) = {(c', v') | {c',v'} = ei>a/({c, v), j) , 0 < j < 21}.
For readability, the flattened form of EVBDDs is used in this section.
E x a m p le 6.5.1 Given a function / as shown in Fig. 6.14 with bound set B —
{x Q ,x 1,X 2 }, cut~set(f, B ) = {a, b,c,d}. □
A lg o rith m decomp-ev: Given a function / represented in an EVBDD Vf and a
bound set B , a disjunctive decomposition with respect to B is carried out in the
following steps:
1. Compute the cut_set_ev with respect to B . Let cu£_se£_eu(v, B ) — {uo, ...,
U k - l } -
2. Encode each node in the cut_set_ev by [log2 k] = j bits.
3. Construct v m’s to represent gm's, 0 < m < j:
Replace each node u with encoding bQ , . . . , 6j_i in the cut_set_ev by term inal
node b m .
127
4. Construct Vf/ to represent function /':
Replace the top part of Vf by a new top on variables go,.. . , gj-i such that
eval(vf>, I) = ui for 0 < / < k — 1, eval(vf», I) = Uk_i for k — 1 < / < 2J.
The correctness of this algorithm can be intuitively argued as follows: For any
input pattern m in the bound set, the evaluation of m in function / will result at
a node in the cut_set_ev with encoding e. The evaluation of m on the gi functions
should thus produce the function values e. The evaluation of e in function / '
should also end at the same node in the cut_set_ev. Thus, the composition of / '
and g{s becomes equivalent to / .
L em m a 6.5.1 Given an EVBDD Vf with variable ordering x0 < ... < £ n- i repre
senting f ( x o ,. . . , Xn-i), a bound set B = {£o,. . . , £ ,-i} and cu tset _eu(vf, B) =
{ u o ,. . . , Uk_i}, if decompsv returns EVBDDs Vf/, v gQ, . . . , v g j _ 1 , then
f (* T 0 ? • • • j -T n — 1) — f (go(xO i • • • j xi-l )? • • • i gj— \ (^0) • • • i * r » — 1) j X{ j • • • » Xn— 1)
where / ' , gQ ,..., gj-\ are the functions denoted by Vf/, v gQ,..., , respectively.
Proof: Consider the behavior of an input pattern (bo, ..., &i_i) on Vf, Vf/ and
v gm’s. Suppose u m is the node we reach in Vf using the input pattern, that is,
eval(v f , { & o , • • •, &«-i)) = um , where u m = f(b 0, ..., £,-,..., Since u m
has been replaced by the 1 th bit of m in v gl, eval(vSi, (b0, . .. = bmi, that
is, gi(b0, ..., = bmr Because of the way we construct Vf/, eval(vf>, (bmo, ...,
= um, that is, f (bmo, ..., bm^ _ £,',..., £n_i) = u — f(^o, ..., b{— x,X{,
..., x n— i). Thus, f (go(bo, ..., ..., gj— i(5o, • ■ • > b % — 1 ), x% , ..., 2:^-1 ) f(bo,
..., 6,_i, Xi, ..., xn_i), for any input pattern in the bound set. □
E x a m p le 6.5.2 Fig. 6.15 shows an example of disjunctive decomposition by using
EVBDDs. The evaluation of the input pattern xq = 1, x\ = 0, and £ 2 = 1 in function
F will end at the leftmost £ 4-node which has encoding 10. The evaluation of the
same input pattern in functions go and g\ would produce function values 1 and
128
3.
1 0
0 0 1 0 1 1
5 6 4 56 34 1 2 6
Figure 6.15: An example of disjunctive decomposition in EVBDD.
0. Then, with go being 1 and g\ being 0 in function F ', it would also end at the
leftmost X 4-node. □
W hen an EVBDD is used to represent a Boolean function, decomp-ev corre
sponds to a disjunctive decomposition algorithm for Boolean functions; when an
EVBDD represents an integer function, then decomp..ev can be used as a disjunc
tive decomposition algorithm for m ultiple-output Boolean functions as shown in
the following example.
E x a m p le 6.5.3 A 3-output Boolean function as shown in Fig 6.16 (a) can be
converted into an integer function as shown in Fig. 6.16 (b) through / = 4 /0 -f
2 /i + / 2 . The application of decomp-ev on F is the one shown in the previous
example. After applying the synthesis paradigm described in Sect. 3.1 on F ', we
can convert / back to a 3-output Boolean function /q, and f 2. □
6.6 In c o m p le te ly S p ecified F u n ctio n s
W hen functions are incompletely specified, the detection of decomposability be
comes very complicated. For example, the compatibility in the Roth-Karp m ethod
is no longer an equivalence relation. The determination of k compatible classes
129
0
b(X
5 6 4 56 34 1 2 6
1 1 0 0
(a) 
Figure 6.16: Representation of m ultiple-output functions.
then requires solving the minimum clique covering problem for the compatibility
graph which is NP-hard [42].
A similar task has to be performed on OBDDs. We first extend OBDDs to include
a third term inal node dc to represent the constant function dc. Next, we compute
the c u ts e t as before. Since each node in c u ts e t may represent an incompletely
specified function, we need to compute the compatibility between any two nodes
in the c u ts e t so that a minimal k can be found. The determ ination of compati
bility between two OBDD nodes, or the compatibility between their corresponding
functions, can be carried out by algorithm is.compatible. After this step, the con
struction of compatibility graph and the computation of minimum clique cover is
the same as in the Roth-Karp algorithm.
130
isjcom patible(f, g) j* f and g are OBDDs with dc */
{
1 if (f = = dc || g = = dc || f = = g)
return 1;
2 if (f = = 0 & & g = = l || f = = 1 & feg = = 0 )
return 0;
3 gi = l-child(g, m in (in d ex(f), m dex(g)));
4 gr = r-child( g, m in(index( f), index( g)));
5 fi = Lchild({, m in(index(f),index(g)));
6 fr = r-child({, m in (in d ex(f), index(g)));
7 }
8 else { fj = fr = f; }
9 return(?s_compah‘6/e(fi, gi) M z is-compatible(fr, gr));
}
6 .7 E x p erim en ta l R e su lts
The algorithm cut^setuall has been implemented and compared with the Roth-
Karp decomposition algorithm implemented in SIS. In particular, the following
command is used on a number of mcnc91 benchmark sets:
“xl-k-decomp1 -n 4 -e -d -f 100” which for every node in the Boolean network,
finds the best bound set of size < 4 that reduces the node’s variable sup
port after decomposition, and then decomposes the node, and modifies the
network to reflect the change.
An equivalent EVBDD-based command was implemented.
1xlJzjdecom p does not process circuits with > 32 inputs.
131
To assign a unique encoding for each EVBDD node, we need integers with 2 * bits
where i is the number of variables considered so far. This is clearly very expensive.
One way to overcome this difficulty is to relax the uniqueness condition (e.g, use 2
instead of 22’). Then, two different EVBDD nodes representing different functions
may be assigned the same encoding. As a result, the size of the cut_set for a
given bound set may be underestimated. This scheme may be used as a filter. For
example, to find the bound set which has the smallest cut_set, we first perform
cut^setjall to find the best ones, and then check for the real cut-sets by moving
the bound variables to the top of the EVBDD.
Results shown in Table 6.1 used 2 as the weight in exclude operation. The
processes were stopped when they took more than 5000 cpu seconds on a Sun
Sparc-Station II with 64 MB of memory. The EVBDD-based approach obtains
significant speed-ups (by an average factor of 35.4).
132
Circuit karp EVBDD Speed-up
5xpl 31.1 2.9 ... 10.7
9sym 513.6 3.7 13878 ...
apex4 2544.8.. 49.8 51.1
misex3 > 5000 ...381.9" 13.1
misex3c > 5000 131.8 37.9
Z5xpl 31.4 4.3 7.3
misex‘ 2 416.8
- g7:7
4.8
sao2 337.9 23.6 14.3
xor5 2.0 '""'0.3""... 6.7
bl2 74.3 6.4 11.6
exlUlU > 5000' 48.5 > 103.1
squar5 473 0.9 4.8
Z9sym 508.2 4.2 121.0
t48l . > 5000 ... 62.1..... ....> 8075....
alu4 > 5000 124.5 >40.2
table3 > 5000 318.6 > 15.7
table5 > 5000 1225.8 > 4.1
cordic > 5000 1331.7 > 3.8
vg2 > 5000 "2051.3“ > 2.4
seq NA > 5000 —
apexl NA > 5000 —
apex2 NA > 5000 —
apex3 NA > 5O00 —
e64 N'A > 5000 —
Average 35.4
Table 6.1: Finding all decomposable forms with bound set size < 4.
133
C h ap ter 7
C on clu sion s
It was demonstrated that by associating an integer with each edge of an OBDD and
giving a new meaning to each node of the OBDD, a new graphical data structure
was created whose domain is that of the integer functions. The new data structure,
called EVBDD, admits arithm etic operations, preserves the canonical property, and
provides the capability to cache computational results. W ith these properties, we
have found EVBDDs to be valuable in many applications.
Because of the compactness and canonical properties, EVBDDs were shown to be
effective for handling verification problems. An extension of EVBDDs, denoted by
SEVBDDs, were successfully used to model conditional statem ents and array data
structure. A future extension is to model loop statem ents and recursive functions
which can then be used for verifying sequential machines. Because of the additive
property, EVBDDs are also useful for solving integer linear programming problems.
A possible improvement is to incorporate linear programming techniques (e.g.,
simplex m ethod) in order to obtain better bounds and hence improve the runtim e
of the procedure.
An OBDD-based Boolean matching algorithm using a level-first search strategy
was presented. Unlike depth-first and breadth-first strategies, a level-first strategy
permits significant pruning of the search space. In addition, a set of filters which
further improve the the performance of the matching algorithm was presented
134
Future research directions include the matching of arithm etic functions and finite
state machines. Again, the key issue is to identify properties which can work as
filters for pruning the search spaces.
Because OBDDs are a compact and canonical representation of Boolean func
tions, the function decomposition algorithms presented here are more efficient than
the cube-based function decomposition implementation. However, the OBDD-based
extraction of common sublogic to minimize the literal cost of the circuits remains
an open problem to be studied in future.
135
R eferen ce L ist
[1] R. L. Ashenhurst, “The Decomposition of Switching Functions,” Ann. Com
putation Lab., Harvard University, vol. 29, pp. 74-116, 1959.
[2] E. Balas, “An Additive Algorithm for Solving Linear Programs with Zero-One
Variables,” Operations Research, 13 (4), pp. 517-546, 1965.
[3] E. Balas, “Bivalent Programming by Implicit Enum eration,” Encyclopedia o f
Computer Science and Technology Vol.2, J. Belzer, A.G. Holzman and Kent,
eds., M. Dekker, New York, pp. 479-494, 1975.
[4] E. Balas, “Disjunctive Programming,” Annals o f Discrete Mathematics 5,
North-Holland, pp. 3-51, 1979.
[5] J. C. Barros and B. W. Johnson, “Equivalence of the Arbiter, the Synchro
nizer, the Latch and the Inertial Delay,” IE E E Trans, on Computers, C-32(7),
July 1983.
[6] H. G. Barrow, “VERIFY: A Program for Proving Correctness of Digital Hard
ware Designs,” Artificial Intelligence, 24:437-491, 1984.
[7] M. Benichou, J. M. Gauthier, P. Girodet, G. Hentges, G. Ribiere and O.
Vincent, “Experiments in Mixed-Integer Linear Programming,” Math. Pro
gramming 1, pp. 76-94, 1971.
136
[8] M. Beardslee, B. Lin, and A. Sangiovanni-Vincentelli, “Communication Based
Logic Partitioning,” Proc. o f the European Design Automation C onf, pp. 32-
37, 1992.
[9] G. V. Bochmann, “Hardware Specification with Temporal Logic: An Exam
ple,” IE E E Trans, on Computers, 31(3):223-231, March 1982.
[10] R. T. Boute, “Representational and Denotational Semantics of Digital Sys
tem s,” IEEE Trans, on Computers, 38(7):986-999, July 1989.
[11] V. J. Bowman, Jr. and J. H. Starr, “Partial Orderings in Implicit Enumera
tion,” Annals of Discrete Mathematics, 1, North-Holland, pp. 99-116, 1977.
[12] K. S. Brace, R. L. Rudell, and R. E. Bryant, “Efficient Implementation of a
BDD Package,” Proc. o f the 27th Design Automation Conference, pp. 40-45,
1990.
[13] R. Brayton and C. McMullen, “The Decomposition and Factorization of
Boolean Expressions,” Proc. Int. Sym. Circ. Syst. (ISCAS-82), pp. 49-54,
May 1982.
[14] R. Brayton, G. Hachtel, C. McMullen, and A. Sangiovanni-Vincentelli, Logic
Minimization ALgorithms for VLSI Synthesis, Boston: Kluwer Academic
Publishers, 1984.
[15] R. Brayton, R. Rudell, A. Sangiovanni-Vincentelli, and A. Wang, “MIS:
Multiple-Level Interactive Logic Optimization System,” IE E E Trans. Corn-
put. Aided Design, vol. CAD-6, no. 6, pp. 1062-1081, Nov. 1987.
[16] R. E. Bryant, “Graph-based Algorithms for Boolean Function M anipulation,”
IEEE Transactions on Computers, C-35(8): 677-691, August 1986.
[17] R. E. Bryant, “Symbolic Boolean M anipulation with Ordered Binary-Decision
Diagrams,” Computing Surveys, Vol. 24, No. 3, pp. 293-318, Sept. 1992.
137
[18] J. R. Burch and D. E. Long, “Efficient Boolean Function Matching,” Int.
Conf. Computer-Aided Design, pp. 408-411, 1992.
[19] A. Camilleri, M. Gordon, and T. Melham, “Hardware Verification Using
Higher-Order Logic,” Technical Report 91, Computer Laboratory, University
of Cambridge, Cambridge CB2 3QG, U.K., Sept. 1986.
[20] S-C. Chang and M. Marek-Sadowska, “Technology Mapping via Transforma
tions of Function Graph,” Proc. International Conf. on Computer Design, pp.
159-162, 1992.
[21] M. J. Ciesielski and S. Yang, “PLADE: A Two-Stage PLA Decomposition,”
IEEE Trans, on Computer-Aided Design, Vol. 11, No. 8, pp. 943-954, Aug.
1992.
[22] E. M. Clarke, M. Fujita, P. C. McGeer, K. L. McMillan, and J. C.-Y. Yang,
“Multi-Terminal Binary Decision Diagrams: An Efficient D ata Structure for
M atrix Representation,” International Workshop on Logic Synthesis, pp. 6a:l-
15, May 1993.
[23] E. M. Clarke, K. L. McMillan, X. Zhao, M. Fujita, and J. C.-Y. Yang, “Spec
tral Transforms for Large Boolean Functions with Applications to Technology
Mapping,” Proc. o f the 30th Design Automation Conference, pp. 54-60, 1993.
[24] A. Cohn, “A Proof of Correctness of the V IPER Microprocessor: the First
Level,” Technical Report 104, Computer Laboratory, University of Cam
bridge, Cambridge CB2 3QG, U.K., Jan. 1987.
[25] O. Coudert, C. Berthet, J. C. Madre, “Verification of Synchronous Sequential
Machines based on Symbolic Execution,” Proc. o f the Workshop on Automatic
Verification Methods fo r Finite State Systems, Grenoble, France, June 1989.
138
[26] 0 . Coudert and J. C. Madre, “Implicit and Incremental Com putation of
Primes and Essential Primes of Boolean Functions,” Proc. o f the 29th De
sign Automation Conference, pp.36-39, 1992.
[27] H. A. Curtis, “A New Approach to the Design of Switching Circuits,” Prince
ton, N .J., Van Nostrand, 1962.
[28] Y-T. Lai and S. Sastry, “Edge-Valued Binary Decision Diagrams for Multi-
Level Hierarchical Verification,” Proc. o f 29th Design Automation Conf., pp.
608-613, 1992.
[29] Y-T. Lai, M. Pedram and S. Sastry, “BDD Based Decomposition of Logic
Functions with Application to FPGA Synthesis,” Proc. o f 30th Design Au
tomation Conf, pp. 642-647, 1993.
[30] W.-M. Dai, M. Sato, and E. S. Kuh, “A Dynamic and Efficient Representation
of Building-Block Layout,” Proc. 24th Design Automation Conf., pp. 376-384,
1987.
[31] R. J. Dakin, “A Tree-Search Algorithm for Mixed Integer Programming Prob
lems,” Comput. J. 9, pp. 250-255, 1965.
[32] G. B. Dantzig, Linear Programming and Extensions, Princeton, N. J.: Prince
ton University Press, 1963.
[33] J. A. Darringer, “The Application of Program Verification Techniques to
Hardware Verification,” Proc. o f 16th Design Automation Conference, pp.
375-381, June 1979.
[34] G. De Micheli, “Symbolic Design of Combinational and Sequential Logic Cir
cuits Implemented by Two-Level Macros,” IE E E Trans, on Computer-Aided
Designs, Vol. 5, No. 9, pp. 597-616, Sept. 1986.
139
[35] G. De Micheli, D. Ku, F. Mailhot, and T. Truong, “The Olympus Synthesis
System,” IE E E Design and Test of Computer, 7(5), pp. 37-53, 1990.
[36] S. Devadas, H.-K. Ma, and A. R. Newton, “MUSTANG: State Assignment
of Finite State Machines Targeting Multilevel Logic Im plementations,” IEEE
Trans, on Computer-Aided Design, Vol. 7, No. 12, pp. 1290-1300, Dec. 1988.
[37] N. J. Driebeck, “An Algorithm of the Solution of Mixed Integer Programming
Problems,” Management Science 12, pp. 576-587, 1966.
[38] C. R. Edwards, “The Application of the Rademacher-Walsh Transform to
Boolean Function Classification and Threshold-Logic Synthesis,” IEEE Trans
actions on Computers, C-24, pp. 48-62, 1975.
[39] H. Eveking and S. Horeth, “Optimization and Resynthesis of Complex D ata
paths,” Proc. o f 30th Design Automation Conf, pp. 637-641, June 1993.
[40] B. J. Falkowski, I. Schafer and M. A. Perkowski, “Effective Computer Meth
ods for the Calculation of Rademacher-Walsh Spectrum for Completely and
Incompletely Specified Boolean Functions,” IE E E Transaction on Computer-
Aided Design, Vol. 11, No. 10, pp. 1207-1226, Oct. 1992.
[41] M. L. Fisher, “The Lagrangian Relaxation M ethod for Solving Integer Pro
gramming Problems,” Management Science, pp. 1-18, 1981.
[42] M. R. Garey and D. S. Johnson, “Computers and Intractability: A Guide to
the Theory of NP-Completeness,” Freeman, San Francisco, 1979.
[43] R. E. Gomory, “Outline of an Algorithm for Integer Solutions to Linear Pro
gram ,” Bulletin o f the American Mathematical Society 64, pp. 275-278, 1958.
[44] R. E. Gomory, “Solving Linear Programming Problems in Integers,” in Com
binatorial Analysis, R.E. Bellman and M. Hall, Jr., eds., American M athe
m atical Society, pp. 211-216, 1960.
[45] p. Gutberlet, H. Kramer, and W. Rosenstiel, “CASCH - a Scheduling Al
gorithm for High Level Synthesis,” Proc. of European Design Automation
Conference, pp. 311-315, Feb. 1991.
[46] G. D. Hachtel and F. Somenzi, “A Symbolic Algorithm for Maximum Flow in
0-1 Networks,” International Workshop on Logic Synthesis, pp. 6b:l-6, May
1993.
[47] P. L. Hammer and S. Rudeanu, Boolean Methods in Operations Research and
Related Areas, Heidelberg, Springer Verlag, 1968.
[48] P. L. Hammer and B. Simeone, “Order Relations of Variables in 0-1 Pro
gramming,” Annals o f Discrete Mathematics, 31, North-Holland, pp. 83-112,
1987.
[49] F. K. Hanna and N. Daeche, “Specification and Verification Using Higher-
Order Logic,” in C. J. Koomen and T. Moto-Oka, eds, 7th In t’ l Symp. Com
puter Hardware Description Languages and their Applications, pp.418-433,
IFIP, North-Holland, Aug. 1985.
[50] S. He and M. Torkelson, “Disjoint Decomposition with Partial Vertex C hart,”
International Workshop on Logic Synthesis, pp. p2a:l-5, 1993.
[51] Yung-Te Lai and Sarma Sastry, “HINTS: A Hardware Interpretation System,”
International Workshop on Formal Methods in VLSI Design 1991.
[52] W -J. Hsu and W-Z. Shen, “Coalgebraic Division for Multilevel Logic Synthe
sis,” Proc. o f 29th Design Automation Conf., pp. 438-442, June 1992.
[53] S. L. Hurst, D. M. Miller and J. C. Muzio, Spectral Techniques in Digital
Logic, London, U.K. : Academic, 1985.
141
[54] T-T. Hwang, R. M. Owens, and M. J. Irwin, “Efficiently Computing Commu
nication Complexity for Multilevel Logic Synthesis,” IE E E Trans, on CAD,
Vol. 11, No. 5, pp. 545-554, May 1992.
[55] C-T. Hwang and Y-C. Hsu, “Zone Scheduling,” IE E E Trans, on Computer-
Aided Design, Vol. 12, No. 7, pp. 926-934, July 1993.
[56] T. Ibaraki, “The Power of Dominance Relations in Branch and Bound Algo
rithm ,” J. Assoc. Comput. Mach. 24, pp. 264-279, 1977.
[57] Y-T. Lai, S. Sastry and M. Pedram, “Boolean Matching Using Binary Deci
sion Diagrams with Applications to Logic Synthesis and Verification,” Proc.
International Conf. on Computer Design, pp.452-458, 1992.
[58] Y-T. Lai, K-R. Pan, M. Pedram, and S. Vrudhula, “FGMap: A Technol
ogy Mapping Algorithm for Look-Up Table Type FPGAs based on Function
Graphs”, International Workshop on Logic Synthesis, 1993.
[59] S-W. Jeong and F. Somenzi, “A New Algorithm for 0-1 Programming based
on Binary Decision Diagrams,” Logic Synthesis Workshop, in Japan, pp. 177-
184, 1992.
[60] N. Karmarkar, “A New Polynomial-Time Algorithm for Linear Program
ming,” Combinatorica, 4:373-395, 1984.
[61] R. M. Karp, “Functional Decomposition and Switching Circuit Design,” J.
Soc. Indust. Appl. Math., Vol. 11, No. 2, pp. 291-335, June, 1963.
[62] B. W. Kernighan and S. Lin, “An Efficient Heuristic Procedure for Partition
ing Graphs,” Bell System Technical Journal, 49(2), pp. 291-307, 1970.
[63] B. W. Kernighan and D. M. Ritchie, The C Programming Language. Engle
wood Cliffs, NJ: Prentice-Hall, 1978.
142
[64] A. H. Land and A. G. Doig, “An Automatic Method for Solving Discrete
Programming Problems,” Econometrica 28, pp. 497-520, 1960.
[65] A. Land and S. Powell, “Computer Codes for Problems of Integer Program
ming,” Annals of Discrete Mathematics 5, North-Holland, pp. 221-269, 1979.
[66] H-T. Liaw and C-S Lin, “On the OBDD-Representation of General Boolean
Functions,” IEEE Trans, on Computers, C-41(6): 661-664, June 1992.
[67] R. N. Mayo, M. H. Arnold, W. S. Scott, D. Stark, and G. T. Hamachi, “1990
DECW RL/Livermore Magic Release,” Western Research Laboratory, WRL
Research Report 90/7, Sept. 1990.
[68] F. Mailhot and G. De Micheli, “Technology Mapping Using Boolean Match
ing,” Eruopean Design Automation Conf., pp. 180-185, 1990
[69] F. Mailhot and G. De Micheli, “Algorithms for Technology Mapping Based
on Binary Decision Diagrams and on Boolean Operations,” IE E E Trans, on
Computer-Aided Design, Vol. 12, No. 5, pp. 599-620, May 1993.
[70] S. Malik, A. Wang, R. Brayton, and A. Sangiovanni-Vincentelli, “Logic Veri
fication using Binary Decision Diagrams in a Logic Synthesis Environm ent,”
Proc. Int. Conf. Computer-Aided Design, pp. 6-9, 1988.
[71] M. C. McFarland and A. C. Parker, “An Abstract Model of Behavior for
Hardware Descriptions,” IE EE Trans, on Computers, C-32(7):621-637, July
1983.
[72] P. Michel, U. Lauther, and P. Duzy, The Synthesis Approach to Digital System
Design, Kluwer Academic Publishers, 1992.
[73] G. J. Milne, “CIRCAL and the Representation of Communication, Concur
rency, and Tim e,” AC M Trans, on Programming Languages and Systems,
7(2):270-298, April 1985.
143
[74] Department of M athematical Sciences, Rice University, Houston, TX 77251.
[75] G. M itra, “Investigation of Some Branch and Bound Strategies for the Solu
tion of Mixed Integer Linear Programs,” Math. Programming 4, pp. 155-170,
1973.
[76] L. G. M itten, “Branch-and-Bound Methods: General Formulation and Prop
erties,” Operations Research, 18, pp. 24-34, 1970.
[77] M. Mlinar, A. C. Parker, and J. T. Pizarro, “MAHA: A Program for Data
Path Synthesis,” Proc. o f 23rd Design Automation Conference, pp. 235-240,
June 1986.
[78] J. Mohnke and S. Malik, “Perm utation and Phase Independent Boolean Com
parison,” EDAC, pp. 86-92, 1993.
[79] B. Moszkowski, “A Temporal Logic for Multilevel Reasoning about Hard
ware,” IEEE Computer, pp. 10-19, Feb. 1985.
[80] G. L. Nemhauser and L. A. Wolsey, Integer and Combinatorial Optimization,
Wiley, New York, 1988.
[81] P. G. Paulin, “High-Level Synthesis of Digital Circuits Using Global Schedul
ing and Binding Algorithms,” Ph.D. thesis, Carleton University, 1988.
[82] J. P. Roth and R. M. Karp, “Minimization over Boolean Graphs,” IB M Jour
nal, pp. 227-238, April 1962.
[83] T. Sasao, “FPGA Design by Generalized Functional Decomposition,” in Logic
Synthesis and Optimization, Sasao ed., Kluwer Academic Publisher, pp. 233-
258, 1993.
144
[84] G. Saucier, C. Duff, and F. Poirot, “State Assigment of Controllers for Op
tim al Area Implementation,” Proc. o f 1st European Design Automation Con
ference, pp. 546-551, 1990.
[85] H. Savoj and H. Y. Wang, “Improved Scripts in MIS-II for Logic Minimization
of Combinational Circuits,” Proc. of Int. Workshop on Logic Synthesis, May
1991.
[86] U. Schlichtmann, F. Brglez, and M. Hermann, “Characterization of Boolean
Functions for Rapid Matching in EPGA Technology Mapping,” Proc. of 29th
Design Automation Conf, pp. 374-379, 1992.
[87] U. Schlichtmann, F. Brglez, and P. Schneider, “Efficient Boolean Matching
Based on Unique Variable Ordering,” International Workshop on Logic Syn
thesis, May 1993.
[88] L. Schrage, Linear, Integer and Quadratic Programming with LINDO, Scien
tific Press, 1986.
[89] C. Sechen and A. Sangiovanni-Vincentelli, “The TimberWolf Placement and
Routing Package,” IEEE Journal of Solid-State Circuits, SC-20(2):510-522,
1985.
[90] J. F. Shapiro, “A Survey of Lagrangian Techniques for Discrete Optimization,”
Annals o f Discrete Mathematics 5, North-Holland, pp. 113-138, 1979.
[91] K. Spielberg, “Enumerative Methods in Integer Programming,” Annals of
Discrete Mathematics 5, North-Holland, pp. 139-183, 1979.
[92] A. Srinivasan, T. Kam, S. Malik and R. Brayton, “Algorithms for Discrete
Function M anipulation,” Proc. Int. Conf. CAD, pp. 92-95, 1990.
145
[93] H. A. Taha, “Integer Programming,” in Mathematical Programming fo r Opera
tions Researchers and Computer Scientists, ed. A.G. Holzman, Marcel Derrer,
pp.41-69, 1981.
[94] Texas Instrum ents, “The TTL Data Book for Design Engineers,” Texas In
struments, 1984.
[95] J. A. Tomlin, “Branch and Bound Methods for Integer and Non-convex Pro
gramming,” in J. Abadie, ed., Integer and non-linear programming, North-
Holland, Amsterdam, 1970.
[96] D. Varma and E. A. Trachtenberg, “Design Autom ation Tools for Efficient
Implementation of Logic Functions by Decomposition,” IE E E Transactions
of Computer-Aided Design, Vol. 8, No. 8, Aug. 1989, pp. 901-916.
[97] J. Vasudevamurthy and J. Rajski, “A Method for Concurrent Decomposition
and Factorization of Boolean Expressions,” Proc. o f Int. Conf. on CAD, pp.
510-513, 1990.
[98] T. Villa and A. Sangiovanni-Vincentelli, “NOVA: State Assignment of Finite
State Machines for Optimal Two-Level Logic Implementation,” IEEE Trans,
on Computer-Aided Designs, Vol. 9, No. 9, pp. 905-924, Sept. 1990.
[99] J. S. Wallis, “Hadamard Matrices,” Lecture Notes No. 292, Springer-Verlag,
New York, 1972.
[100] T. Yoshimura and E. S. Kuh, “Efficient Algorithms for Channel Routing,”
IE E E Trans, on Computer-Aided Designs, 1(1), pp. 25-35, 1982.
146

Asset Metadata

Creator Lai, Yung-Te (author)

Core Title Logic verification and synthesis using function graphs

Contributor Digitized by ProQuest (provenance)

School Graduate School

Degree Doctor of Philosophy

Degree Program Computer Engineering

Degree Conferral Date 1993-12

Publisher University of Southern California (original), University of Southern California. Libraries (digital)

Tag oai:digitallibrary.usc.edu:usctheses,OAI-PMH Harvest

Format theses (aat)

Language English

Permanent Link (DOI) https://doi.org/10.25549/usctheses-oUC11255803

Unique identifier UC11255803

Identifier DP22869.pdf (filename)

Legacy Identifier DP22869

Document Type Dissertation

Format theses (aat)

Internet Media Type application/pdf

Type texts

Source University of Southern California Dissertations and Theses (collection), University of Southern California (contributing entity)

Access Conditions The author retains rights to his/her dissertation, thesis or other graduate work according to U.S. copyright law. Electronic access is being provided by the USC Libraries in agreement with the author, as the original true and official version of the work, but does not grant the reader permission to use the work if the desired use is covered by copyright. It is the author, as rights holder, who must provide use permission if such use is covered by copyright.

Repository Name University of Southern California Digital Library

Repository Location USC Digital Library, University of Southern California, University Park Campus MC 2810, 3434 South Grand Avenue, 2nd Floor, Los Angeles, California 90089-2810, USA

Repository Email uscdl@usc.edu

Linked assets

University of Southern California Dissertations and Theses