Page 1
Bounds on the OBDD-Size of Integer
Multiplication via Universal Hashing
Philipp Woelfel
Dept. of Computer Science
University Dortmund
D-44221 Dortmund
Germany
phone: +49 231 755-2120
fax: +49 231 755-2047
e-mail: philipp.woelfel@cs.uni-dortmund.de
Abstract
Bryant [5] has shown that any OBDD for the function MULn−1,n, i.e. the middle bit
of the n-bit multiplication, requires at least 2n/8nodes. In this paper a stronger lower
bound of essentially 2n/2/61 is proven by a new technique, using a universal family
of hash functions. As a consequence, one cannot hope anymore to verify e.g. 128-bit
multiplication circuits using OBDD-techniques because the representation of the
middle bit of such a multiplier requires more than 3 · 1017OBDD-nodes. Further,
a first non-trivial upper bound of 7/3 · 24n/3for the OBDD-size of MULn−1,n is
provided.
Key words: OBDDs, integer multiplication, binary decision diagrams, branching
programs, MUL
1 Introduction and Results
Ordered Binary Decision Diagrams (short: OBDDs) belong to the most impor-
tant data structures for representing boolean functions. Efficient algorithms
on OBDDs are known for all important operations, as e.g. synthesis operation,
equivalence test, satisfiability test or minimization. Therefore, OBDDs have
found a wide variety of applications, especially in the areas of model checking
and circuit verification.
Preprint submitted to Elsevier Science25 January 2005
Page 2
Definition 1 Let Xn= {x1,...,xn} be a set of Boolean variables.
(1) A variable ordering on Xnis a bijection π : {1,...,n} → Xn, leading to
the ordered list π(1),...,π(n) of the variables.
(2) A π-OBDD on Xnfor a variable ordering π is a directed acyclic graph
with one root and two sinks satisfying the following properties: One sink
is labeled with 0, the other with 1. Each inner node is labeled by a variable
in Xnand has two outgoing edges, one labeled by 0, the other by 1. If
an edge leads from a node labeled by xito a node labeled by xj, then
π−1(xi) < π−1(xj). This means that any path on the graph passes the
nodes in an order respecting the variable ordering π.
(3) The computation path of an input a = (a1,...,an) ∈ {0,1}nis the path
starting at the root and leaving any xinode over the edge labeled by the
value of ai. The OBDD represents a function f : {0,1}n→ {0,1} if for
any a ∈ {0,1}nthe sink reached by the computation path of a is labeled
with f(a).
(4) The size of a π-OBDD is the number of its nodes. The π-OBDD-size of
a Boolean function f (short: π-OBDD(f)) is the size of the minimum
π-OBDD computing f. Finally, the OBDD-size of f (short: OBDD(f))
is the minimum of π-OBDD(f) for all variable orderings π.
For an in-depth discussion of OBDDs and their operations we refer to [14].
OBDDs can be used, e.g. for circuit verification as follows. If one wants to test
a circuit for a function f against its specification (function g), one can use
syntheses operations in order to obtain π-OBDDs for f and g and then check
whether f and g are equal by using the equivalence test. The minimization
algorithm is used to ensure that the OBDDs obtained during such a procedure
are as small as possible.
Although each single operation used in a such a verification procedure is pos-
sible in polynomial (i.e. quadratic or even better) time with respect to the
sizes of the corresponding input OBDDs, the total procedure may be infeasi-
ble because the sizes of the involved OBDDs may grow almost quadratically
with each synthesis operation.
It is not surprising that a lot of research effort has been spent in trying to
verify multiplier circuits using OBDDs. However, it took until 1998 until it
was possible to compute an OBDD for the 16-bit multiplication circuit c6288,
one of the most important ISCAS (International Symposium on Circuits and
Systems) benchmark circuits [18]. The resulting OBDD consisted of more than
40 million nodes, the largest OBDD obtained during the synthesis operations
even had 110 million nodes and the maximum memory requirement was 3,803
megabyte. According to the author’s knowledge, nobody could successfully
compute an OBDD for a larger multiplier circuit, yet.
2
Page 3
These experiences do not necessarily mean that there are no small OBDDs
for e.g. 16- or 32-bit multiplier circuits, because the size of a π-OBDD can
be quite sensitive to the chosen variable ordering π, and finding a variable
ordering leading to small or even minimal π-OBDDs is a hard problem (see
[1,4,12]). Therefore, it is necessary to prove large lower bounds for the OBDD-
size of integer multiplication in order to be sure that verification of multipliers
using OBDDs is infeasible.
There is also a more theoretical motivation for the investigation of the OBDD-
size of multiplication. It can be easily seen that almost all functions require
an exponential number of elements in any realization by networks using only
primitive elements. But this would not be disturbing as long as for all practical
relevant families of functions small representations of a certain kind exist.
Therefore, one is interested in finding exponential lower bounds for the size
of OBDDs (and other representation types) computing important and natural
families of functions.
Definition 2 The Boolean function MULk,n: {0,1}2n→ {0,1} computes the
bit zkof the product (z2n−1...z0) of two integers (yn−1...y0) and (xn−1...x0).
The first step towards bounding the size of OBDDs for integer multiplication
was done by Bryant in 1986 [4]. He showed that for any variable ordering
π, there exists an index k, such that the π-OBDD-size for MULk,nis at least
2n/8. This result, though, would still allow the possibility that one might obtain
polynomial size OBDDs for all functions MULk,nby choosing different variable
orderings for different output bits. In 1991, Bryant found that computing the
middle bit of multiplication (that is MULn−1,n) requires a π-OBDD containing
2n/8nodes for any variable ordering π [5].
Although this proves the exponential size of OBDDs for multiplication, the
bound is - as stated e.g. by Bollig and Wegener in [2] - not satisfactory. This is
because Bryant’s bound would still allow the possibility that one can construct
64-bit multipliers represented by OBDDs containing only 256 nodes while on
the other hand it is widely conjectured that OBDDs computing MULn−1,n
have a size of at least 2n. This would mean that such a multiplier could not
even be realized with millions of nodes. Since one would like to use OBDDs for
realistic applications one is interested in either finding such small constructions
or a better lower bound. The following result, which will be proven in the next
section, provides the second alternative:
Theorem 3 The OBDD-size of MULn−1,nis at least 2⌊n/2⌋/61 − 4.
This bound shows that any OBDD for 64-bit multiplication must be con-
structed of more than 70 million nodes and therefore the representation of
64-bit multipliers using OBDDs requires a huge amount of resources. The ver-
ification of 128-bit multipliers is infeasible because more than 3·1017OBDD-
3
Page 17
Proof of Theorem 4: Let X = {x0,...,xn−1}, Y = {y0,...,yn−1} and let
π be the variable ordering of X ∪ Y with
?
Similar as in the proof of Theorem 13 we describe an algorithm which queries
all bits in the order defined by π and which stores after each query a value
which corresponds to a node of an OBDD.
π(1),...,π(2n)
?
= (y0,...,yn−1,x0,...,xn−1).
Let m = ⌈n/3⌉−1. First, the algorithm queries the variables y0, ..., yn−1, x0,
..., xm−1and stores the values of all queried variables. I.e., the upper part of
the OBDD is a complete binary tree whose 2n+mleafs are the OBDD-nodes
labeled with ym. Let now skand s′
i.e.
?
i=0
In the proof of Theorem 13 we have already shown that s′
determined by s′
kbe defined as in the proof of Theorem 13,
sk =y ·
k−1
?
2i· xi
?
div2k
ands′
k= skmod 2n−k.
k+1is uniquely
k, y and xk. This followed right from (8) which states that
s′
k+1=
?
(y · xk+ s′
k)div2
?
mod 2n−k−1.
However, since the term on the right hand side is taken modulo 2n−k−1, we
could have taken y modulo 2n−kbeforehand. This shows that s′
dent from the bits yn−k,...,yn−1. Hence, s′
by s′
be seen from (9), that MULn−1,n(x,y) is uniquely determined by s′
xn−1.
k+1is indepen-
k+1is in fact uniquely determined
kand the values of the variables y0,...,yn−k−1and xk. Similarly, it can
n−1, y0and
Therefore, before querying xk, 0 ≤ k ≤ n − 2, it suffices for our algorithm
to store the value of s′
compute s′
can “forget” yn−k−1. Before the last query (i.e. the xn−1-query), s′
as y0are stored. Then MULn−1,n(x,y) is uniquely determined by the outcome
of the last variable query.
kas well as the values of y0,...,yn−k−1 in order to
k+1by the next query xk. Then, once xkis queried, the algorithm
n−1as well
It remains to bound the size of the OBDD defined by this algorithm by bound-
ing the number of possible states after each step of the algorithm. For s′
are 2n−kpossible values and (y0,...,yn−k−1) can take 2n−kvalues, too. Hence,
for k ≥ m+1, 22n−2kxk-vertices are sufficient for the OBDD. Adding the two
sinks as well as the complete binary tree of size 2n+m+1− 1 for the y-vertices
and the xk-vertices with k ≤ m, we obtain an OBDD-size of
kthere
2n+m+1+ 1 +
n−1
?
k=m+1
22n−2k= 2n+m+1+ 1 + 4 ·
= 2n+m+1+ 1 + 4 ·4n−m−1− 1
n−m−2
?
i=0
22i
3
< 2n+m+1+4n−m
3
.
17
Page 18
Since m = ⌈n/3⌉ − 1, we have m = (n + τ)/3 − 1 for some τ ∈ {0,1,2}. This
yields an upper bound of
2(4/3)n+τ/3+4(2/3)n−τ/3+1
3
= 2(4/3)n·
?
2τ/3+41−τ/3
3
?
.
A simple case distinction shows that the term in parentheses is maximal for
τ = 0 and thus is bounded by 7/3. Therefore, the OBDD constructed here has
at most (7/3) · 2(4/3)nvertices.
2
Acknowledgments
The author thanks Ingo Wegener for valuable comments on early drafts of the
proofs.
References
[1] B. Bollig and I. Wegener. Improving the variable ordering of OBDDs is NP-
complete. IEEE Transactions on Computers, 45:993–1002, 1996.
[2] B. Bollig and I. Wegener. Asymptotically optimal bounds for OBDDs and the
solution of some basic OBDD problems. In Proceedings of the 25th International
Colloquium on Automata, Languages, and Programming (ICALP), pp. 187–198.
2000.
[3] Y. Breitbart, H. B. Hunt III, and D. J. Rosenkrantz.
binary decision diagrams representing boolean functions. Theoretical Computer
Science, 145:45–69, 1995.
On the size of
[4] R. E. Bryant. Graph-based algorithms for boolean function manipulation. IEEE
Transactions on Computers, C-35:677–691, 1986.
[5] R. E. Bryant.
representations of boolean functions with applications to integer multiplication.
IEEE Transactions on Computers, 40:205–213, 1991.
On the complexity of VLSI implementations and graph
[6] J. L. Carter and M. N. Wegman. Universal classes of hash functions. Journal
of Computer and System Sciences, 18:143–154, 1979.
[7] M. Dietzfelbinger. Universal hashing and k-wise independent random variables
via integer arithmetic without primes.
Symposium on Theoretical Aspects of Computer Science (STACS), volume 1046
of Lecture Notes in Computer Science, pp. 569–580. 1996.
In Proceedings of the 13th Annual
18
Page 19
[8] M. Dietzfelbinger, T. Hagerup, J. Katajainen, and M. Penttonen. A reliable
randomized algorithm for the closest-pair problem.
25:19–51, 1997.
Journal of Algorithms,
[9] Y. Mansour, N. Nisan, and P. Tiwari.
universal hashing. Theoretical Computer Science, 107:121–133, 1993.
The computational complexity of
[10] S. Ponzio. A lower bound for integer multiplication with read-once branching
programs. In Proceedings of the 27th Annual ACM Symposium on Theory of
Computing (STOC), pp. 130–139. 1995.
[11] M. Sauerhoff and P. Woelfel. Time-space tradeoff lower bounds for integer
multiplication and graphs of arithmetic functions. In Proceedings of the 35th
Annual ACM Symposium on Theory of Computing (STOC), pp. 186–195. 2003.
[12] D. Sieling.
for OBDD minimization. In Proceedings of the 15th Annual Symposium on
Theoretical Aspects of Computer Science (STACS), pp. 205–215. 1998.
On the existence of polynomial time approximation schemes
[13] D. Sieling and I. Wegener. NC-algorithms for operations on binary decision
diagrams. Parallel Processing Letters, 48:139–144, 1993.
[14] I. Wegener. Branching Programs and Binary Decision Diagrams - Theory and
Applications. SIAM, 2000.
[15] M. N. Wegman and J. L. Carter.
functions. In Proceedings of the 20th Annual IEEE Symposium on Fountations
of Computer Science (FOCS), pp. 175–182. 1979.
New classes and applications of hash
[16] P. Woelfel. Efficient strongly universal and optimally universal hashing. In
Mathematical Foundations of Computer Science: 24th International Symposium
(MFCS), volume 1672 of Lecture Notes in Computer Science, pp. 262–272. 1999.
[17] P. Woelfel.
universal hashing. In Proceedings of the 18th Annual Symposium on Theoretical
Aspects of Computer Science (STACS), volume 2010 of Lecture Notes in
Computer Science, pp. 563–574. 2001.
New bounds on the OBDD-size of integer multiplication via
[18] B. Yang, Y.-A. Chen, R. E. Bryant, and D. R. O’Hallaron. Space- and time-
efficient BDD construction via working set control. In Proceedings of the Asia
South-Pacific Design Automation Conference (ASPDAC), pp. 423–432. 1998.
19