Mathematik / Informatik

Transcription

1 .. UNIVERSITAT TRIER Mathematik / Informatik Forschungsbericht Nr Ecient Boolean Manipulation with OBDD's Can be Extended to FBDD's Jordan Gergov and Christoph Meinel FB IV { Informatik Universitat Trier D{54286 Trier Electronic copies of technical reports are available: Printed copies: Via FTP: Via WWW: Via URL ftp://ftp.informatik.uni-trier.de/pub/users-root/reports URL Send a mail to ftpmail@ftp.informatik.uni-trier.de, subject HELP, for detailed instructions Trierer Forschungsberichte Fachbereich IV - Mathematik / Informatik.. Universitat Trier D Trier ISSN

2 Ecient Boolean Manipulation with OBDD's Can be Extended to FBDD's Jordan Gergov and Christoph Meinel FB IV { Informatik Universitat Trier D{54286 Trier Revised Version Abstract OBDD's are the state{of{the{art data structure for Boolean function manipulation since basic tasks of Boolean manipulation such as testing equivalence, satisability, or tautology, and performing single Boolean synthesis steps can be done eciently. In the following we show that the ecient manipulation of OBDD's can be extended to a more general data structure, so{ called FBDD's. In detail, the advantages of using FBDD's instead of OBDD's are FBDD's are generally more (sometimes even exponentially more) succinct than OBDD's, FBDD's provide, similarly to OBDD's, canonical representations of Boolean functions, and in terms of FBDD's basic tasks of Boolean manipulation can be performed similarly ecient as in terms of OBDD's. The power of the FBDD{concept is demonstrated by showing that the veri- cation of the benchmark circuit design for the hidden weighted bit function HWB proposed by Bryant can be carried out eciently in terms of FBDD's while, for principial reasons, this is impossible in terms of OBDD's. 1

3 1 Introduction The need for data structures for Boolean functions becomes obvious if one has applications in mind as circuit design, optimization, verication, testing, etc. Let us consider e.g. basic problems of logic verication. By means of hardware description languages circuits can be described at a very high level of abstraction, that allows the designer to specify the behavior of a circuit before realizing it. In order to validate these specications and in order to verify a designed circuit, with respect to its specication, formal methods were developed that lead to problem descriptions in terms of Boolean functions. The verication problem is then solved by analyzing and manipulating these functions. Let us consider as an example the problem of determining whether a combinational circuit C correctly implements a given speci- cation S. That is to test whether f C = f S, if f C and f S are the functions realized by C and S, respectively. One possibility to do this [e.g. Eve91, FFK88, MWBS88, Bry92] is, rst, to construct representations for f C and f S (usually in terms of the primary inputs), and, second, to perform the equivalence test for both functions in terms of these representations. Hence, ecient algorithms for solving the verication task under consideration require ecient algorithms for deriving the representations of the involved Boolean functions (e.g. from a circuit description) as well as ecient algorithms to solve the equivalence test or similar tests such as satis- ability or tautology in terms of these representations. In the past, a great variety of representations of Boolean functions such as truth{ tables, disjunctive (DNF) and conjunctive normal forms (CNF), Reed{Muller{expansions, various types of formulas, Boolean circuits, or branching programs have been investigated. However, the demand for supporting the mentioned basic tasks in Boolean manipulation became obvious only then when computer applications really had started to work with more complex Boolean functions. In order to come to a full understanding of the fundamental trade{o between succinctness of the representation and eciency of solving the basic tasks observe that the complexity has to be measured in the length of the representations of the input functions. Hence, working e.g. with truth{tables one has much time for computations. However, such a representation requires in any case space ressources that are exponential in the number of primary inputs. On the other side, working with e.g. formulas one often obtains very succinct and, consequently, space ecient representations but solving e.g. the equivalence test becomes co-np{hard. Unfortunately, a systematic inspection of the dierent succinct representation schemes [e.g. GM92a] has shown that allmost all of them do not support ecient solutions of the Boolean manipulation basic tasks. More worse, performing the basic tasks often requires the solution of NP{hard problems. The only exceptions seem to be BDD{based Boolean function representations [e.g. Ake78, Bry86, Mei91, GM92a] 2

4 that provide with so{called OBDD's the state{of{the{art data structure for Boolean functions. They allow 1. canonical representations (and, hence, ecient solutions of the equivalence test and similar tests such as satisability or tautology test), and allow 2. ecient performance of binary Boolean synthesis steps (and, hence, ecient procedures for deriving the OBDD{representation of a Boolean function from a given circuit description). Due to these nice properties, OBDD's are successfully used in many applications such as, for example, sequential circuit verication [e.g MB9, BCM9, Fil91], testing [e.g. Bec92, KBS93], or logic optimization [Kar89]. For a survey see [Bry92]. Unfortunately, OBDD{representations are not very succinct and, hence, not very space{ecient. It arises the question whether there are more sophisticated BDD{ representations that are, rst, more succinct and space{ecient as OBDD's, and, second, allow ecient solutions of the basic tasks of Boolean manipulation similarly as OBDD's do. A number of OBDD{extensions were proposed with the aim to overcome the mentioned disadvantages of OBDD's [e.g. ADG91, JPHS91, BJAAF92]. However, the obtained increase in space{eciency of the representation has to be paid in the mentioned approaches with co{np{completeness of the equivalence test [GM92a]. A natural candidate for an OBDD{extension that allows ecient equivalence test (at least probabilistical [BCW8]) are BDDs that read input variables in the course of computation at most once, so{called FBDD's. Since OBDD's are special structured BDDs with this read{once{only property, FBDD's indeed generalize the OBDD{concept. 2 OBDD's { a BDD-based Data Structures for Boolean Functions BDD-based data structures for Boolean functions use the following representations schemes. Denition. (BDD, OBDD, FBDD) A binary decision diagram (BDD) over a set X n = fx 1 ; : : : ; x n g of Boolean variables is a directed acyclic graph with one source and at most two sinks labeled by and 1. Each non-sink node v is labeled by a Boolean variable l(v) 2 X n, and has two outgoing edges one labeled by and the other by 1. The computation path for an input a = (a 1 ; : : : ; a n ) starts at the source. At an inner node with label x i the outgoing edge with label a i is chosen. The BDD P represents a Boolean function f 2 IB n if the computation path for each input a leads to the sink with label f(a). 3

5 f is sometimes denoted by f P. A BDD is called a free binary decision diagram (FBDD) if, on each path, each variable is tested at most once. An ordered binary decision diagram (OBDD) is an FBDD with the property that on each path the variables are tested in a xed order. Examples of an FBDD and an OBDD are given in Figure 1. Generally we draw BDDs in such a way that, if the edges are not labeled, then we assume the left edge to be labeled by and the right edge by 1. @R x 2 @R x 3 x 4 x 2 AQ QQ A AA AA Q QQs AU + AU 1 (a) @R x 2 x 2 A AA A A x 3 x 3 AA S C CCSS AU 1 x 4 C S CC S A SSAA C CW Sw AU 1 x 3 (b) Figure 1. Example of an FBDD (a) and an OBDD (b) for the function f(x 1 ; x 2 ; x 3 ; x 4 ) = x 1 x 2 x 3 + x 1 x 2 x 4 + x 1 x 3 x 4 + x 1 x 2 x 3 : Because of the remarkable property that (the logarithm of) BDD{size corresponds to (nonuniform) Turing machine space under the name of branching programs BDD{ representations have been extensively studied in complexity theory [e.g. Weg87, Mei89]. The theoretical interest in FBDD{representations which are known in complexity theory as read{once{only branching programs arises from a similar correspondence to eraser Turing machine space. It is well known that each Boolean function f 2 IB n over X n can be represented in terms of BDDs, in terms of FBDD's or, for any variable ordering, in terms of 4

6 OBDD's. Optimal BDD{representations are, in comparison with two-level-representations such as DNFs or CNFs or with multi-level-representations such as Boolean formulas, more succinct and space{ecient [e.g. Mei89]. However this succinctness makes it often dicult or sometimes even infeasible to perform the basic tasks of Boolean manipulation. For example, it is a co{np-complete problem to test whether two BDDs represent the same Boolean function [CHS74]. The situation changes dramatically if one works with restricted types of BDDs. Then, it is sometimes possible to perform eciently the basic tasks of Boolean manipulation, although restriction properties have to be maintained in the course of the computation. Bryant [Bry86] was the rst who observed that OBDD's have this property. In more detail, OBDD's possess the following outstanding properties. Fact 1 [Bry86]. 1. With respect to a xed variable ordering the representation of a Boolean function by means of a reduced OBDD is canonical, i.e. uniquely determined. 2. Let P and P be two OBDD's with the same variable ordering. Each binary Boolean synthesis step can be performed in time O(size(P ) size(p )). Due to these properties OBDD's dened over a xed variable ordering are well suited to be used as a data structure for Boolean functions [Bry86]. Indeed, nowadays such OBDD's are the state{of{the{art data structure for Boolean functions utilized in various packages for applications in CAD [e.g. BRB91]. However, the disadvantage of OBDD data structures is the often very low space eciency of the OBDD{ representations. Although wide classes of practically important Boolean functions possess { at least with respect to some well{suited variable orderings { space{ecient (i.e. polynomial size) OBDD{representations, there are many important functions without such succinct representations. For example, there exist Boolean functions such as integer multiplication, hidden weighted bit function (HWB), or indirect storage access function (ISA) that can not be represented by OBDD's of polynomial size [FHS78, Bry91, BHR91] for any variable ordering. 3 Computational Advantages of the FBDD's Although there are many Boolean functions such as e.g. all symmetric functions for which optimal FBDD{representations are OBDD's for many important functions the restriction of FBDD's to OBDD's causes an exponential increase in size. Here we are going to discuss some Boolean functions with the property that, for each variable ordering, the OBDD{size is exponential in the FBDD{size. 5

7 The rst idea to construct examples of Boolean functions with small (i.e. polynomial size) FBDD{size and large (i.e. exponential size) OBDD{size is to consider Boolean functions of the form f(x ; x 1 ; : : : ; x n ) = x f (x 1 ; : : : ; x n ) + x f 1 (x 1 ; : : : ; x n ) where f and f 1 have polynomial size OBDD's for variable orderings, and 1, and exponential size OBDD's for 1, and, respectively. If we replace the single multiplexer variable x by a larger (k > 2) multiplexer tree (see Figure 2), and if we take functions f 1 ; f 2 ; : : : ; f k with polynomial size OBDD's which do not have a good variable ordering in common we can get a large class of Boolean functions with small FBDD{size and large OBDD{size. MUX f 1 f 2 f k Figure 2. Due to a similar idea, Fortune, Hopcroft and Schmidt have constructed in [FHS78] an FBDDp P of size smaller than 3n 2 such that each OBDD for F HS = f P has size n=2(log at least 2 3 n+1)=2. Verication methods and circuit realizations of F HS are presented in [JBAF92]. A second interesting example is the indirect storage access function ISA. ISA is dened for n = 2 k + k variables as follows: Let m = 2 k =k, and let the variables of ISA be partitioned in m + 1 groups y ; : : : ; y k1 ; x ; : : : ; x k1 ; : : : ; x (m1)k ; : : : ; x mk1 : If P k1 s= y s2 s = l 1 < m then the output of ISA is x j with j = P k1 i= x (l1)k+i 2 i, and otherwise. Breitbart, Hunt III and Rosenkrantz have proven that any OBDD computing ISA has size at least 2 n=logn1 [BHR9]. On the other hand, they have shown that ISA 6

8 can be computed by an FBDD (even by a decision tree) of size at most 2n 2 =logn. Register y y @ Memory x x 1... x k1 x k x k+1... x 2k1. x (l1)k x (l1)k+1... x lk x (m1)k x (m1)k+1... x mk1 Figure 3. Indirect storage access function ISA. Finally we are going to discuss in more detail the hidden weighted bit function HW B discussed by Bryant in [Bry91]. Let wt(x) be the number of ones in the input assignment x = (x 1 ; x 2 ; : : : ; x n ) 2 f; 1g n. If wt(x) > then HW B(x) = x wt(x), and HW B(x) = otherwise. Although each OBDD{representation of HW B is of exponential size [Bry91] it can be computed by a polynomial (even a quadratic) size FBDD. To explain this we use a construction due to Bryant [Bry92b]. It is based on the computation of appropriately chosen restrictions of HW B. If x i:j represents x i ; : : : ; x j then ( : wt(xi:j ) = H(x i:j ) = x i+wt(x i:j)1 : else; 7

9 and ( 1 : wt(xi:j ) = j i + 1 G(x i:j ) = x i+wt(x i:j) : else: One can easily verify that and HW B(x 1 ; x 2 ; : : : ; x n ) = H(x 1:n ); H(x i:j ) = x j H(x i:j1 ) + x j G(x i:j1 ); G(x i:j ) = x i H(x i+1:j ) + x i G(x i+1:j ); G(x i:i ) = H(x i:i ) = x i : The main idea is explained in Figure 4. Simultaneously we compute H 1:n and G 1:n. Identical restrictions on the same level are merged together. Since, on each level, k is xed, we have at most 2n nodes on each level. Furthermore, on any source{ to{sink{path each variable is tested. Hence, the FBDD size of HW B is at most 2n 2. H 1:n1 G 1:n1 H 2:n @R p p p G 1:n H i:i+k p p p G j:j+k p p p 1 i; j n H i:i p p p G j:j H HHHH H H Hj 1 Figure 4. Construction of an FBDD P HW B HW B. that computes the hidden weighted bit function 8

10 After having seen that there are important functions with small size FBDD's whose OBDD{sizes are, with respect to any variable ordering, exponential, let us mention a further computational advantage of FBDD's over other Boolean function representations. Due to [BCW8] we can assign to each FBDD a signature that allows to test functional equivalence of FBDD's probabilistically in polynomial time. This property applied to OBDD's is the basis of very ecient hash techniques that are used extensively in eciently working OBDD{packages such as in the package of Brace, Bryant and Rudell [BRB9]. The signatures of Boolean functions have found many further applications [YBAF92, Kri93, KBS93]. Since signatures can be computed for FBDD's similarly as for OBDD's these hash techniques can be used to work with FBDD's, too. We remark only, that no similar property is known for other (compact) Boolean function representations. 4 FBDD Types In order to extend the ecient manipulation of OBDD's to FBDD's we have to show that it is possible to perform single Boolean synthesis steps in terms of FBDD's similar eciently (i.e. in polynomial time) as in the case of OBDD's. To be more precise, let be a Boolean operator 2 IB 2. Then, by {SY N F BDD (P; P ; P ) we denote the problem of constructing an FBDD P for the function f = f f from given FBDD{representations P and P for f and f. Sometimes we suppress the operator and write easily SY N F BDD. SY N OBDD denotes the similar problem for OBDD's. Unfortunately, investigations of the complexity of SY N F BDD have shown that performing Boolean synthesis steps in terms of FBDD's is NP-hard [GM92a]. The reason for the intractability of SY N F BDD is caused by the dierent ways the input FBDD's can test the variables. Indeed, considering OBDD's instead of FBDD's the same eect can be observed: Performing a Boolean synthesis step (SY N OBDD ) with OBDD's of dierent variable orders is NP-hard, too [GM92a]. However, if we restrict the problem to OBDD's of the same variable order (SY N OBDD ) the problem becomes eciently solvable in time O(size(P ) size(p )) [Bry86]. The goal of this section is to introduce formally the notion of a type of an FBDD that generalizes the linear variable ordering of OBDD's and that allows to canoncially represent Boolean functions in terms of FBDD's with respect to any given complete type, and to eciently perform a single Boolean synthesis step for FBDD's of the same complete type (SY N F BDD ). Denition. (Type, tp(p).) An (FBDD{)type is dened similarly as an FBDD with the only exception that it 9

11 possesses merely one sink that is labeled by a symbol t. If P is an FBDD than tp(p ) is derived easily from P by identifying the sinks of P. x 1 S 1 S 1 SS SS / Sw / Sw x x 2 x 2 x 3 3 A 1 A 1 A 1 A 1 AA AA AA AA AU AU AU AU x 3 x 4 x 4 x x 3 2 x 4 x 4 x 2 Q QQQ J 1 JJ CC CC Q Q + CW CW 1 t Figure 5. An FBDD P and the type tp(p ). P x 1 tp(p) There are two syntactical reduction rules usually applied to BDDs, FBDD's, OBDD's, and types in order to reduce their sizes without any functional change. An important observation is that these reductions do not change substantially the way a BDD, an FBDD, or an OBDD tests the input variables. This is the reason we can use these reductions to generalize the notion of variable order to FBDD's. Merging rule: If two nonterminal nodes u and v have the same label l(u) = l(v), and if u = v and u1 = v1, then eliminate one of these two nodes and redirect all incoming edges to the other node. Figure 6 illustrates the application of the merging rule to type tp(p ) of Figure 5. Observe, that, for each input assignment, the sequence of variable tests remains invariant w.r.t. to applications of the merging rule. Moreover, if one considers BDDs as an algebraical structure, then the application of the merging rule denes a congruence relation on the set of nodes of the BDD. For this reason sometimes we speak of the merging rule as of an algebraical reduction. Deletion rule: If v = v1 for a nonterminal node v, then eliminate v and redirect all incoming edges to v. Figure 7 illustrates the application of the deleting rule. A node on which deletion rule can by applied is called simple reducible. In opposite 1

12 to the merging rule the deletion rule decreases the information contained in a type. x 1 S 1 S 1 SS SS S / S Sw / Sw x 2 x 3 x 2 x 3 A 1 J AA JJ A / J^ AU A AU x 3 xm 4 x 2 x 3 xm 4 xm 4 x 2 Z ZZ 1 CC CC CC Z ZZ~ CW CW t t x 1 tp(p) Figure 6. Application of the merging rule to tp(p ) from Figure 5. x 1 S 1 S 1 SS SS S / Sw / S Sw x 2 x 3 x 2 x 1 J 1 JJ B S 1 BB 1 J^ / B SSSw x 3 x 4 x 2 x 3 BB x 2 Z ZZ 1 1 Z 1 ZZ 1 B 1 Z Z ZZ~ ZZ~ BBN = = t t x 1 Figure 7. Application of the deleting rule to the type from Figure 6. 11

13 Denition. (Reduced FBDD's and types.) A FBDD P is called reduced if neither the merging rule nor the deletion rule can be applied to P. A type or an FBDD P is said to be algebraically reduced if the merging rule can not be applied to or to P. x 1 S 1 SS S / Sw x 2 x 1 J 1 JJ J^ x 3 x 4 x 2 Z ZZ Z ZZ~ = t red a (tp(p)) Figure 8. Algebraical reduced type for the type tp(p ) of Figure 5. Proposition 1. (Unique reduction.) The reduced FBDD obtained from an FBDD P by applying merging and deletion rule is uniquely determined and can be computed in linear time. Similarly, the algebraically reduced FBDD and the algebraically reduced type obtained by applying the merging rule are uniquely determined and can be computed in linear time. Proof. For an FBDD P we denote a reduced FBDD by red(p ), and an algebraical reduced FBDD by red a (P ). Similar, for a type we denote by red a () an algebraical reduced type red a (). First we prove that red a (P ) and red a () are uniquely determined. Two nodes u and v are said to be algebraical congruent (u a v) if 1. l(u) = l(v), and 2. u a v and u1 a v1 (if u and v are inner nodes). Obviously, a denes an equivalence relation. Interpreting the left{son{relation (v) and the right{son{relation (v1) as unary operations on the set of nodes, the 12

14 labels l(v) as unary predicates on the set fx 1 ; x 2 ; : : : ; x n g [ f; 1g, then, by means of a few simple axioms, P or can be considered as an algebra. Now it can be checked easily that a is in fact a congruence relation. The factorization over this relation produces red a (P ) or red a (), respectively. This is true since FBDD's or types rooted in algebraical congruent nodes are isomorphic. Hence, any two merging sequences of maximal length merge all concruent nodes into a single node and lead to the same result red a (P ) or red a (). The algebraical idea behind the proof of the uniqueness of red a (P ) and red a () can not be applied directly to red(p ) since there is a fundamental dierence between the merging and the deletion rule. In terms of universal algebra this dierence can be explained by the fact that the relation a dened by the merging rule is a congruence relation while the relation to be dened in the following by means of the merging and the deletion rule is merely an equivalence relation. Two nodes u and v of the FBDD P are said to be equivalent (u v) if 1. u and v are algebraical congruent (u a v), or 2. one of them is the only successor of the other node in P, or 3. there exist nodes v 1 ; v 2 ; : : : ; v k such that u v 1 v 2 v k v. Observe that neither the deletion rule nor the merging rule does aect the equivalence of two nodes in P. However, it is clear that any application of the merging or the deletion rule merges together two dierent equivalent nodes. It is easy to see that in order to prove the uniqueness of red(p ) it suces to prove that P can be transformed into an FBDD all of whose equivalent nodes are merged together. The proof can be done easily by induction on the dierence between size(p ) and the number of equivalence classes on P. If this dierence is zero, i.e. if there do not exist two dierent equivalent nodes in P then we have nothing to merge together. P is reduced. But if the dierence is positive then we can always nd two equivalent nodes which can be merged together by means of the deletion rule or the merging rule. At the next step we can use the induction hypothesis. What about the complexity of constructing red(p ), red a (P ) or red a (). Reductions of BDDs were already discussed by Akers [Ake78]. An ecient algorithm for the construction of red(p ) was developed by Bryant [Bry86]. By the way, OBDD{packages [e.g. BRB9] do not use separate reduction procedures. However, reduction can be performed in the average by means of linear many arithmetical operations Finally, the algorithm of Bryant was improved in [SW92] to run in deterministic linear time by replacing the sorting procedure by a (linear time) bucket sort technique. In order to identify FBDD's testing the variables in a similar way it suces to compare their types. We dene the notion of a subtype in analogy to the notion of a linear suborder. Denition. (Subtype.) Let be type. A type is called a subtype of,, if = or if can be 13

15 constructed from by applying the merging and the deletion rule. x 1 S 1 SS / Sw x 2 x 3 A 1 A 1 AA AA AU AU x 3 x 4 x 4 x 1 CC CC @R CW CW t x 1 S 1 SS / Sw x 2 x 3 B S 1 BB 1 SSw / x 3 B x 2 Z BB 1 1 Z ZZZZZ~ ZZ~ BBN = t Figure 9. A type and a subtype. It is easy to see that, with respect to, the set of all types constitutes a partially ordered set. Denition. (Complete type, FBDD of type.) A type over X n = fx 1 ; x 2 ; : : : ; x n g is complete if, on each source-to-sink path, each variable of X n is tested. Let be complete type. An FBDD P is of type if there exists a type such that tp(p ), and red a ( ) = red a (). Due to the denition of a type of an FBDD we can always assume that is algebraically reduced. Sometimes, by write FBDD to indicate an FBDD's to be of a complete type. Obviously, a single FBDD can belong to several types. Variable orderings provide very simply structured complete types the so{called OBDD{types (for an example see Figure 1). However, in Section 3 it was shown that for important functions such OBDD{types are not optimal. To give a more interesting example of a type of an FBDD we deduce the type HW B = tp(p HW B ) of the FBDD P HW B for the hidden weighted bit function HW B described in Section 3. Since each variable is tested on each source to sink path HW B is a complete type. Figure 11 shows HW B for n = 7 by giving types for H 1:n (= HW B) and for G 1:n. 14

16 x 1 1 x 2 1 x 3 p p p x n 1 t Figure 1. Example of an OBDD{type. Proposition 2. (Ecient type{check for FBDD's) Let P be an FBDD P, and let be a complete type. Then it can be checked eciently whether P is of type. Proof: Since the apply algorithm to be presented in Section 5 produces always FBDD's consistent with the given type, in most practical applications we do not need to check whether an FBDD belongs to a predened type. Hence it suce to scetch an O(size(P )size(p )) time test whether there exists a type such that two FBDD's P and P are of type [GM92b]. In particular, for P = P and tp(p ) = we answer the question whether P is of type. Each node v of an FBDD or a type can be characterized by the set s v of variables that are tested on a v-to-sink path. s v can be computed with a straightforward traverse algorithm in time that is linear in the output. We say that two nodes u and v are consistent if, for l(u) 6= l(v), it is not the case that l(u) 2 s v as well as l(v) 2 s u. Now, if we run the algorithm synthesis (the apply procedure described in Section 5.2) taking P and P as inputs then we can check whether the sources of every recursive call of synthesis are consistent. (Let us remark that in this case the procedure synthesis needs no input type and can work with any binary Boolean operation since the resulting FBDD is not of interest.) By induction it can be easily proved that, all checked pairs of nodes are consistent if and only if there exists a common type for P and P. 15

17 x 6 x 1 x 7 @@R AAU x 5 x 1 x 6 x 2 x 7 x AAU x 4 x 1 x 5 x 2 x 6 x 3 x 7 x 3 x 1 x 4 x 2 x 5 x 3 x 6 x 4 x 7 x 2 x 1 x 3 x 2 x 4 x 3 x 5 x 4 x 6 x 5 x 7 x 6 AB A B A B A B A B AAU BBN AAU BBN AAU BBN AAU BBN AAU BBN x 1 x 2 x 3 x 4 x 5 x 6 x 7 ZZ AA Z A AA Z A ZZ@@ AA ZZ~ AU = t x 1 Figure 11. The type HW B = tp(p HW B ) for n = 7 of the FBDD for the hidden weighted bit function given in Section 3 given by means of the types for H 1:n (= HW B) and for G 1:n. ( HW B roots in the source labeled by x 7.) 16

18 5 Ecient Solutions of the Basic Tasks of Boolean Manipulation in Terms of FBDD's 5.1 Canonical FBDD Representations Now we are ready to prove that, with respect to a given complete type, reduced FBDD's similarly to reduced OBDD's provide a canoncial representation for Boolean functions. In order to do this we start with the following easy observation. For each input variable x there exists a BDD that consists of exactly one nonterminal node labelled by x, a {sink, and a 1{sink. Let us call this BDD (it is actually an OBDD) the standard representation of x. Proposition 3. Let be a complete type over X n, and let x 2 X n. The standard representation of x is of type. Proof: Since is a complete type the nodes labelled by x form a cut in. By means of the deletion rule we can eliminate all predecessors of the nodes labeled by x in. After iterated applications of the merging rule we get a type such that a single node labelled by x is the only predecessor of the sink t. Finally, using the deletion rule we can successively construct from the standard representation of x. Theorem 4. (Canonical FBDD representation.) Let be a complete type over X n and let f 2 IB n. There is, up to isomorphism, exactly one reduced FBDD of type that represents f. Proof. There is exactly one complete binary decision tree T for f such that red a (T ) = red a (). Let P be an FBDD for f of type. It is easy to see that tp(p ) tp(t ). Since P and T represent the same Boolean function, P can be constructed from T by applying the merging and deletion rules. As a consequence of Proposition 1 we get red(p ) = red(t ). As an easy consequence of Theorem 4 and Proposition 1 we obtain an ecient algorithm that solves the equivalence problem EQU F BDD (P; P ) for two FBDD's P and P of type. Corollary 5. EQU F BDD, the equivalence of two FBDD's P and P of type can be decided in linear time O(size(P ) + size(p )). 17

19 Let us mention that the best result for solving EQU F BDD is a probabilistic polynomial time algorithm [BCW8]. 5.2 Ecient Performance of Boolean Synthesis Steps In the following we show how the ecient APPLY procedure for OBDD's of the same variable ordering [Bry86] can be extended to FBDD's of the same type. In the meantime, similar results could be obtained in [SW92]. Theorem 6. (Ecient Boolean synthesis of FBDD's.) Let be a binary Boolean operation, and let P, P be two FBDD's of the same complete type. An FBDD P of type representing the Boolean function f = f P f P can be constructed in time O(size() size(p ) size(p )). Before proving the Theorem we remark only that in many cases, binary Boolean synthesis steps for FBDD's can be performed in quadratic instead of cubic time. This is true for instance if we consider FBDD's of bounded width types or if at least one of the input FBDD's is large enough (i.e. each variable appears on each source{ to{sink path). Then we can eliminate the factor size() and obtain a time bound of O(size(P )size(p )). The quadratic upper bound O(size(P )size(p )) can be obtained also if we do not require as result an FBDD of type [GM92b]. However, since also small size FBDD's such as the standard representations (i.e. FBDD's of size 1) and for certain types the result of the synthesis can be of size O(size()) there is no hope to eliminate the factor size() from the general upper bound. Proof: We start with a brief sketch of the synthesis algorithm. Algorithm for SY N F BDD Input: - a binary Boolean operation 2 IB 2 ; - a complete type ; - two FBDD's P and P of type ; Output: - an FBDD P of type that represents f = f P f P ; begin synthesis(,, P, P, Q); compute P := red(q); return(p ); end. 18

20 We give now a short recursive description of the procedure synthesis(,, P, P, P ) which is a generalization of the apply procedure proposed in [Bry86]. Let top() denote the top variable (the label of the source) of. Then j top( )= is the type rooting in the -successor, 2 f; 1g, of the source of. Similar notations are used in the case of FBDD's. The terminal case is reached if one of the two input FBDD's P and P represents a constant. Then the recursion stops, and the output FBDD can be derived by modifying the sinks of the other FBDD. For instance, if P is 1-sink and = each -sink of P has to be replaced by a -sink, 2 f; 1g. synthesis(,, P, P, P ) begin if (P or P is a sink) /* terminal case */ then return the result; /* the construction of P is straightforward */ else x := top(); synthesis(, j x=, P j x=, P j x=, P ); synthesis(, j x=1, P j x=1, P j x=1, P 1 ); construct P such that top(p ) = x and P j x= = P, 2 f; 1g; return(p ); end; For any 2 IB 2, by means of the classical Shannon expansion applied in the form f f = xf j x= f j x= + xf j x=1 f j x=1 ; each recursion step of synthesis(,, P, P, P ) can easily be veried. Let us only remark that if P and P are of type then P j x=, P j x= are of type j x=. Since modications of the sinks of an FBDD do not change its type we get, as result, an FBDD P of type. To improve the running time we use a global table T of size size() size(p ) size(p ). Let us consider the call synthesis(,, P, P 2 2, Q). Since the restrictions Qj x= have the property that either x = top(q) or x does not appear in Q the sources v; v ; v of, P2, P 2 correspond to nodes of, P and P, respectively. If synthesis is supported by the table T such that T [v; v ; v ] contains a pointer to the result of the corresponding synthesis call (or nil if synthesis was not called on these nodes) we can save much computation and bound the running time by the size of T. Let us remark an important property of this straightforward synthesis algorithm. The procedure synthesis generates as result an FBDD P which is not reduced. Moreover, each variable appears on each source-to-sink path in P. That is why for the next call of synthesis applied to P and P new as input (P new is any FBDD of type 19

21 ) we do not need anymore the type (the information of is always encoded in P ). Hence, for repeated applications of synthesis we get a quadratic upper bound O(size(P )size(p new )) for the running time. As an example, let us mention that the FBDD P HW B for the hidden weighted bit function described in Sections 3 encodes all informations of the type HW B (Section 4). Hence, working with P HW B we do not need at all the type HW B. (For an application we refer to Section 6.) Finally we remark, that the algorithm presented in the proof of Theorem 6 is not optimal. The programming techniques used e.g. in the OBDD{package developed by Brace, Rudell and Bryant [BRB9] can be applied also in the case of FBDD's. For instance with the help of an appropriate hash table we can force synthesis to produce only reduced FBDD's. Hence, no reduction algorithm is needed. 6 FBDD's versus OBDD's Let us start the comparision between the FBDD data structure and the OBDD data structure with a general remark. Since both data structures provide canonical representations, since binary Boolean synthesis steps can be performed, in both cases, in quadratic time (at least for \large" inputs which is the interesting case in practice), and since FBDD's provide more { sometimes even exponentially more { concise representations than OBDD's, in any application that is based on these properties it makes sense to use FBDD's instead of OBDD's. However, since OBDD's are especially easily structured FBDD's, and since there is a great variety of reasonable heuristics [e.g. FS9, BRKM91] for designing ecient OBDD's it seems to be a meaningful strategy to work with OBDD's as long as they t into the computer. Only when OBDD's became too large then one should work with the more ecient and sophisticated structure of FBDD's. Before we start to demonstrate the power of the FBDD{concept by showing that the verication of the circuit design for the hidden weighted bit function HWB given in [Bry91] can be eciently carried out in terms of FBDD's let us present some ideas how to perform eciently variable quantication in terms of FBDD's. 6.1 FBDD's and variable quantications. First insights. Beside of performing two{valued logical synthesis some applications of OBDD's are based on the possibility of an ecient performance of variable quantication [e.g. CMB9, Bry92]. For x 2 X n and f 2 IB n variable quantications are dened by the identities 9xf = fj x= + fj x=1 and 8xf = fj x= fj x=1 : 2

22 Starting with an OBDD for f these operations can be performed by deriving OBDD's for both restrictions fj x= and fj x=1 and carrying out the according Boolean synthesis step. However, in terms of FBDD's the situation is more dicult. Starting with an FBDD P for f similarly to the case of OBDD's one can easily construct the FBDD's P and P 1 for the restrictions fj x= and fj x=1 of f by deleting in P each node v labelled by x and, to obtain P, replacing it by the {successor node v, or, to obtain P 1, by the 1{successor node v1. But now we get into trouble. Since, in general, P and P 1 are not of the same FBDD{type no ecient algorithm for performing the necessary Boolean synthesis step for P and P 1 is known [GM92b]. Nevertheless there are many and important situations for which, also in terms of FBDD's, ecient quantication is possible. In the following we describe two paradigmatic situations. First let us consider an FBDD P of type, and let all nodes of that are labeled by a variable x are simple reducible (i.e. can be reduced by means of the deletion rule). Then it is guaranteed that the FBDD's for the restrictions constructed from P are of the same type. Hence quantication can be performed eciently similar as in the case of OBDD's. In order to illustrate the importance of that observation let us discuss an interesting application in the verication of switch-level circuits [FMK9]. A modeling method of a transistor as a switch is as follows: If a switch (transistor) is on, then source and drain have the same value. Hence, the circuit shown in Figure 12 is modeled as a switch using propositional logic as where d is an internal signal. (a! (c d))(b! (d e)) (1) c a b d Figure 12. A transitor{level circuit. 21 e

23 Since d is not observable from outside the circuit, d can be considered to be an existential quantied variable. To get the relationship of only external signals (a; b; c; e) the internal signal d must be eliminated. If the logical description of the circuit (e.g. (1)) is expressed in terms of FBDD's then this operation can be eciently implemented if quantication of internal signals can be eciently performed. Since, from the very beginning, the external signals are known the following heuristic for designing well{suited FBDD-types guarantees that quantication of internal signals can be done eciently. We separately create an appropriate FBDD{type e that is complete with respect to the variables corresponding to the external signals, and an appropriate order i of the variables corresponding to the internal signals. (Obviously, i denes an OBDD{type that is complete with respect to the internal variables.) Then, starting with e, a complete FBDD{type is designed by including as occasion demands i piecewise into e. As a result we get a type where we can quantify, restrict and compose in the internal variables without problems. Without going into further details we mention merely that this technique generally can be successfully applied to all approaches that are based on verifying modularized circuits. A second more general situation where variable quanitication can be perform ef- ciently in terms of FBDD's is the following: Assume the set X n of variables is partitioned into blocks X (1) ; : : : ; X (k). We consider types that are segmented, i.e. that consists of segments r ; 1 r k; such that segment r starts with exactly one node and tests the variables from X (r). See Figure 13 for an example. Now, if P is an FBDD of a segmented type then it is easy to see that restricting simultaneously all variables of a block provides FBDD's that are again of type. Hence, due to Theorem 6, the variables of each block can be (simultaneously) quantied eciently although in the course of restricting the single variables of a block, there emerge FBDD's that, in general, are not of type. Let us mention that in many application we do not quantify single variables but blocks of variables. For example, consider any FBDD P of the type cited in Figure 13. If we restrict x k+1 to and to 1, respectively, then we obtain two inconsistent FBDD's whose types are incomparable. This is true, since, for the input assigment x k =, in P j x k+1= the variable x k+2 ist tested before x k+3 while in P j x k+1=1 the variable x k+3 ist tested before x k+2. Figure 14 shows the type j x k+1= of P j x k+1= and the type j x k+1=1 of P j x k+1=1, respectively. 22

24 A Z ZZZ~ = x k+1 x k+1 P 1 1 ) PPPPPPPq x k+2 x k+3 J JJ x k+3 J x k+2 Q QQQs JJJ^ = +. x k x k+4. Q QQQs. Figure 13. Segment of a segmented type. 23

25 x k+2 + Q QQQs 1 = B BB B x BBN k+2 Z ZZZ~ + x k x k x k+4. Q QQs. x k+3 x k x k 1 Q QQ = Qs B BB B x BBN k+2 Z ZZZ~ Z~ + x k+3. x k+4. Q QQs. x k+3 jx k+1 = jx k+1 =1 Figure 14. Segments of the restrictions j x k+1= and j x k+1=1 of type cited in Figure The power of FBDD's in circuit verication. The hidden weighted bit function. In the following we review a result described in detail in [GM93b] that shows that the verication of the circuit design proposed by Bryant in [Bry91] for the hidden weighted bit function HW B can be carried out eciently in polynomial space using FBDD's. This demonstrates the power of the FBDD{concept since in [Bry91] it was shown that working with OBDD's exponential space is needed. Recall from Section 3 that the hidden weighted bit function HWB can be mathematically specied by means of the recursive equations: HW B(x 1 ; x 2 ; : : : ; x n ) = H(x 1:n ); and H(x i:j ) = x j H(x i:j1 ) + x j G(x i:j1 ); G(x i:j ) = x i H(x i+1:j ) + x i G(x i+1:j ); G(x i:i ) = H(x i:i ) = x i : 24

26 >From the above description an FBDD P HW B for HW B can be derived easily (see Section 3). Its type HW B was drawn in Section 4. The circuit design C for HW B given in [Bry91] leads to a nearly optimal VLSI implementation of area time 2 complexity O(n 1+ ) for any >. The main idea of this design is illustrated in Figure 15. HW B P!!!!! PP 6 P PP a aaaa 6 P PP 6 P 6 P PP a aaaa 6 P PP 6 w 2 w 1 w x 7 x 6 x 5 x 4 x 3 x 2 x 1 Figure 15. Circuit design C for the hidden weighted bit function HWB. The w ; w 1 ; w 2 denote the weight of (x 1 ; x 2 ; : : : ; x 7 ) (i.e. wt(x 1 ; x 2 ; : : : ; x 7 ) = w + w w ). >From Figure 15 it becomes obvious how C looks like for any n 2 IN. P For simplicity we assume n = 2 m m1 1. In this case log wt(x) < m and wt(x) = w i= i2 i. In order to verify C in terms of FBDD's of type HW B we have to construct a reduced FBDD P C of type HW B for the function f C computed by C, and then to test its equivalence (in fact the equality since FBDD{representations of a xed type are canonical) with P HW B. For constructing P C we introduce, motivated by the logical structure of C, a few (m = log P (n + 1)) internal variables w ; w 1 ; : : : ; w m1 which m1 satisfy the equation wt(x) = i= w i 2 i. The FBDD P cited in Figure 16 exactly mirrors the main design idea for C. Obviously, size(p ) = 2n. 25

27 J JJ^ w m2 w m2 B BBN q q q w m1 q J JJ^ J J JJ^ JJ^ w w w w q J J JJ^ JJ^ x 1 x n1 x n q q q q q q q J J JJ^ JJ^ 1 1 q q q Figure 16. The output function of the circuit of HWB in terms of FBDD over the primary inputs and the new internal variables. Now, let us consider the type cited in Figure 17. It is easy to see that P is an FBDD of type. Now we start to eliminate all internal variables in the order w m1 ; w m2 ; : : : ; w. We are going to prove that all FBDD's arising in this elimination process are of small size. Let us mention that, as in the example of Section 6.1, we can quantify, restrict and compose in the internal variables. Let f i, 1 i < log(n + 1), denotes the Boolean function computed by P after the elimination of w m1 ; w m2 ; : : : ; w mi. In order to describe f i and its FBDD we consider the Shannon decomposition of f i in w m1 ; w m2 ; : : : ; w mi which can be illustrated by the tree cited in Figure

28 w m1 1 w m2 1 w m3 p p p w 1 HW B Figure 17. Denition of the type. w m(i+2) B BBN q q q w m(i+1) J JJ^ q J JJ^ J J JJ^ JJ^ w w w w q J J JJ^ JJ^ mi f () i f (1) i f (2 1) q q q q q q q w m(i+2) q q q i Figure 18. Visualization of the cofactors of the Shannon expansion of f i in the w m1 ; : : : ; w mi : 27

29 If wt i (x) = wt(x) div 2 m(i+1) = P m1 j=mi w j2 j then f (k) i (x 1 ; x 2 ; : : : ; x n ) = x wt i(x)+k: The function f (k) i can be described easily in the following way. We partition the set of input variables x ; x 1 ; : : : ; x n (for simplicity x denotes the constant ) in 2 i groups of 2 mi variables X (1) = fx ; : : : ; x 2 mi 1 g; X (2) = fx 2 mi; : : : ; x 2 mi+1 1g; : : : X (2i ) = fx 2 m 2 mi; : : : x n g: With wt i (x) we choose the appropriate group. k is the oset we need to determine the output variable. k depends only on w ; : : : ; w m(i+1). To extract from C an FBDD P C for its output we do the following. We start with P. Then we construct an FBDD of type for w m1 and eliminate w m1 from P by means of the compose operation. In the second step, by means of the compose operation, we eliminate in the same manner w m2. At the last step we eliminate w. What we get is an FBDD P C of type HW B for the circuit C. In more detail, we begin with P (size(p ) = 2n) and construct successively FBDD's for the functions w m1 ; f 1 ; w m2 ; f 2 ; : : : ; w ; f m = HW B. Under the assumption that we use for each single synthesis step the programming techniques (hash table, hash-based cash etc.) presented in [BRB9] then in usual practical implementations the expected space complexity for extracting P C equals the size of the maximal reduced FBDD derived for one of the above mentioned functions. Since C computes HW B, and since P C is a reduced FBDD of type HW B it is equal to P HW B and, hence, of quadratic size. That is why the space complexity of the verication has to be at least quadratic. What about the FBDD{sizes of the functions f i and w i In order to estimate the FBDD{size of the functions f i in the above process it is sucient to design small FBDD's of type for the f (k) i. Using the tree of Figure 18 the size of the resulting FBDD for f i is, since 2 mi n; at most a factor of n larger than the size of such HW B FBDD for f (k) i : Let us mention some useful properties of HW B. If we exclude the last two levels (the sink t and its predecessors) each node of HW B can be labeled by a function G i:j or H i:j. The source is labelled by H 1:n. We claim that the number of ones we have tested on any path from H 1:n to H i:j or G i:j equals i1 or i, respectively. Hence, we can consider HW B to be a counting schema. The proof of this claim follows easily by induction on j i. H i;j, G i;j can be a {successor, a 1{successor of H i;j+1 or G i1;j, respectively. If the induction hypothesis holds for H i;j+1 and G i1;j then it is true for H i;j and G i;j, too. An easy consequence of the above mentioned counting property of HW B is that each symmetric Boolean function including the functions w i can be realized by means of 28

30 FBDD's of type HW B of at most quadratic size. Now we are going to design an HW B FBDD for the f (k) i. Without loss of generality let k =, i.e. f () i (x 1 ; : : : ; x n ) = x wt i(x). Let us take the, with respect to, uniquely determined complete decision tree of f () i of type HW B. We consider the restrictions of f () i computed on level l. The number of ones tested on a path from the source to a node on level l labeled by x s has at most two values. If w is the number of ones for u and v where l(u) = l(v) = x s then u and v correspond to the same restriction if and only if x w div 2 mi1 has the same value on the source{to{u and on the source{to{v paths. Altogether the nodes on level l labeled by x s compute at most four dierent restrictions. Hence, the number of restriction on level l is at most 4n and, hence, the size of the HW B FBDD for f () i is at most 4n 2. Analogously we obtain the same upper bound for f (k) i for any k. That is why the FBDD of f i has size at most 4n 3. We remark only that the size can be further reduced if all similarities between the HW B FBDD's of f (k) i will be merged together. Altogether it is shown that C can be veried in terms of FBDD's of type HW B with low degree polynomial space and time. Since, for principal reasons, this is impossible in terms of OBDD's this example makes the power of the FBDD{concept evident. 7 Conclusions In the paper we extend the feasible manipulation in terms of OBDD's to FBDD's. In detail we have shown that these FBDD's provides much more (sometimes even exponentially more) ecient representations for Boolean functions as OBDD's do (Section 3), reduced FBDD's of a xed type provide canonical representations (Theorem 4), and basic tasks of Boolean manipulation such as performing a Boolean synthesis step, testing equivalence, satisability or tautology can be performed similar eciently in terms of FBDD's as in terms of OBDD's (Theorem 6, Corollary 5). Instead of giving experimental evidence we prove formally for each problem size n that the benchmark circuit for the hidden weighted bit function proposed in [Bry91] can be veried in terms of at most cubic size FBDD's (Section 5.2) while it was shown by Bryant that verication in terms of OBDD's in any case needs exponential space complexity. What spellt out to be more dicult to do in terms of FBDD's than in terms of OBDD's are operations that are based on restrictions (e.g. variable quantication or 29

31 composition). However, we have characterized (Section 5) some situations that frequently occure in practical applications for which these operations can be performed ecently in terms of FBDD's, too. An open and interesting problem is to develop heuristics for creation good types. Of course, this is an extension of the problem of determining good variable orders for OBDD applications. Since there is much greater freedom to dene types than to dene orders this problem seems to be very trickery. However, all what is know about OBDD's can be used if working with FBDD's. For example, a useful strategy to work with FBDD's is to work with OBDD's (as extremely easy structed FBDD's) as long as the OBDD's under consideration t into the computer. Only when OBDD's became to large then one should (try to) work with the more ecient and sophisticated FBDD's. 8 References [Ake78] S. B. Akers: Binary Decision Diagrams, IEEE Trans. Comput. C-27, 6 (Aug.), 59{516, [ADG91] P. Ashar, S. Devadas, A. Ghosh: Boolean Satisability and Equivalence Checking Using General Binary Decision Diagrams, Proc. of International Conference on Computer Design (Cambridge, Mass., Oct.), 259{264, [Bec92] B. Becker: Synthesis for Testability: Binary Decision Diagrams, Proc. of 9th Annual Symposium on Theoretical Aspects of Computer Science (Feb.), Lecture Notes in Computer Science 577, 51{512, [BCW8] M. Blum, A. K. Chandra, M. N. Wegman: Equivalence of Free Boolean Graphs Can Be Decided Probabilistically in Polynomial Time, Inf. Process. Lett. 1, 2 (Mar.), 8{82, 198. [BHR91] Y. Breitbart, H. B. Hunt III, D. Rosenkrantz: The Size of Binary Decision Diagrams Representing Boolean Functions, Manuscript, [BRB9] K. S. Brace, R. L. Rudell, R. E. Bryant: Ecient Implementation of a BDD Package, Proc. of 27th ACM/IEEE Design Automation Conference (Orlando, June), 4{45, 199. [Bry86] R. E. Bryant: Graph-Based Algorithms for Boolean Function Manipulation, IEEE Trans. Comput. C-35, 6 (Aug.), 677{691, [Bry91] R. E. Bryant: On the Complexity of VLSI Implementations and Graph Representations of Boolean Functions with Applications to Integer Multiplication, IEEE Trans. Comput. 4, 2 (Feb.), 25{213,