A set of products is a prime cover of a Boolean function f if it is made of prime implicants of f, and if the sum of its products covers f. Finding a prime cover, ...
Implicit Prime Cover Computation: An Overview Olivier Couderty
Jean Christophe Madrey
yDEC, Paris Research Laboratory
85 Avenue Victor Hugo 92500 Rueil Malmaison, FRANCE
Henri Fraissez
Herve Touatiy
zBull Corporate Research Center
Rue Jean Jaures 78340 Les Clayes-sous-bois, FRANCE
Abstract A set of products is a prime cover of a Boolean function f if it is made of prime implicants of f , and if the sum of its products covers f . Finding a prime cover, an irredundant prime cover, or a minimal prime cover of a function f is a problem that arises in several elds of computer science, for instance in logic synthesis, automated reasoning, realiability analysis, and some optimization problems. This paper shows how the three prime cover computation problems mentioned above can be eciently solved using implicit manipulations of sets of products.
1 Introduction Computing a prime cover, an irredundant prime cover, or a minimal prime cover of a Boolean function has several applications in computer science. In logic synthesis, an irredundant prime cover, or better, a minimal prime cover, provides the user with an ecient 2-level logic implementation of a single or multi output Boolean function [2, 24, 14]. In reliability analysis, prime covers are a way for either exhaustively, or concisely, representing the causes of failure of a system [13, 9]. In automated reasoning, a prime cover can be either a set of minimal demonstrations, or the normalization of a formula into conjunctive normal form for further computations [12, 15, 16, 23, 18]. The problem of computing (irredundant, minimal) prime covers of Boolean functions was rst addressed by Quine in the 1950's [21]. Since that date, e orts have been done to elaborate ecient prime cover computation procedures [22, 17, 2, 24, 25, 14, 3]. For some problems, for instance for computing all the prime implicants, or for computing a minimal prime cover, the bottleneck of the procedures proposed in the past is the huge numbers of products one has to manipulate for some functions. This paper presents prime cover computation algorithms using a graph based implicit representation of sets of products that makes their complexities related to the sizes of the graphs and not anymore to the numbers of products to manipulate. The paper is divided into 6 parts. Section 2 describes the problems that will be addressed here and presents the concepts that will be used to solve them. Section 3 presents the implicit prime cover computation algorithm and Section 4 presents the implicit irredundant prime cover computation algorithm. Section 5 presents an original minimal prime cover computation procedure, whose cyclic core computation is based on set covering problem transpositions. Section 6 gives experimental results obtained with the di erent algorithms presented in the paper and discusses them.
2 De nition and Notations 2.1 Boolean Functions, Products, and Prime Covers We consider Boolean functions from the set f0; 1gn into the set f0; 1; g. We note f 1 and f the sets f ?1 (1) and f ?1 (1) [ f ?1 () respectively. An element x of f0; 1gn such that f 1 (x) = 1 is called a minterm 1
of f . We note (fxk ; fxk ) the Shannon expansion of f with respect to xk [1]. We assume the reader familiar with binary decision diagrams (BDDs) [4, 5], which are a canonical graphical representation of Boolean functions. A product is a conjunction of literals, i.e., a propositional variable xk or its negation xk . We note Pn the set of 3n products that can be built from the set of variables fx1; : : :; xng. The subset relation \" is a partial order on the set Pn. Elements of sets of products P and Q will be noted p; p0 and q; q0. A set of products P is maximal if and only if (i ) there do not exist two products p and q of P such that p q. A product p is an implicant of a Boolean function f i p f 1 . A product p is a prime implicant of f i it is a maximal element w.r.t. \" of the set of implicants of f .SA set of products P is a prime cover of the function f i it is made of prime implicants of f and f 1 ( p2P p) f 1 . This cover is irredundant i there does not exist any proper subset of P that is a prime cover of f , and it is a minimal prime cover of f if there does not exist a prime cover of f that is made of strictly less products than P . Any subset P of Pn can be partitioned in the following canonical way:
P = P1k [ (fxk g Pxk ) [ (fxk g Pxk ); where P1k , Pxk , and Pxk are sets of products in which the variable xk does not occur. For example, for P = fx1x4; x2; x2x4; x2x3g, we have P12 = fx1x4 g, Px2 = fx3g, and Px2 = f1; x4g.
2.2 Implicit Representation of Sets of products A rst graph based implicit representation of sets of products, called metaproduct, has been introduced in [6]. Its eciency has been demonstrated by computing huge sets of prime implicants of Boolean functions. A much more compact representation, called IPS for Implicit Prime Set, has then been used for representing subsets of prime implicants [7]. However IPSs can only represent subsets of prime implicants, so they cannot be used when non prime sets of products need to be manipulated. More recently, S. Minato presented a generalization of IPSs, called Zero-suppressed BDDs [19]. This representation, that we will call CS for combinatorial set in the sequel, mixes the compactness of IPSs and the genericity of metaproducts. The CS representation is a graph based canonical representation of sets made of combinations of a nite number of objects. Union, intersection, and set di erence can be performed on this representation with a cost related to the size of the CSs, but not to the number of elements of the sets denoted by the CSs. All the algorithms presented here compute prime covers P by a divide and conquer strategy that consists of computing the sets P1k , Pxk , and Pxk . Since the CS of the sets P1k , Pxk , and Pxk resulting from the canonical decomposition of the set of products P with respect to the variable xk , can be obtained from the CS of P in constant or linear time, it is very easy to implement with CSs the algorithms manipulating sets of products that use such a divide and conquer strategy.
3 Prime Cover Computation In this section we show that the implicit prime implicant computation algorithm presented in [6] can be slightly transformed to obtain a prime cover computation algorithm manipulating sets of products in a implicit way. This transformation is based on the following theorems.
Lemma 1 Consider a Boolean function f and the variable xk . Any prime implicant of fxk (respectively of fxk ) that is an implicant of fxk (respectively of fxk ) is a prime implicant of fxk ^ fxk , and thus a prime
implicant of f .
Lemma 2 Consider a Boolean function f and a set of products P . The subset of products of P that are implicants of f can be computed using the call KeepImplicants (P; f; 1) of the following algorithm. The proof of this algorithm can be found in [8].
2
function KeepImplicants (P : SetOfProducts ; f : BooleanFunction ; k : int): SetOfProducts ; if f = 0 return ; if f = 1 or f = return P ; if P = return ; let P = KeepImplicants (P1k ; fxk ; k + 1); Q = KeepImplicants (P1k ; fxk ; k + 1); R0 = KeepImplicants (Pxk ; fxk ; k + 1); R1 = KeepImplicants (Pxk ; fxk ; k + 1); in return (P \ Q) [ (fxk g R0) [ (fxk g R1);
Figure 1. The Algorithm KeepImplicants .
Theorem 1 The call PrimeCover (f; 1) of the algorithm PrimeCover produces a prime cover of the Boolean function f .
function PrimeCover (f : BooleanFunction ; k : int): SetOfProducts ; if f = 0 return ; if f = 1 or f = return f1g; let P 0 = PrimeCover (fxk ; k + 1)
P 1 = PrimeCover (fxk ; k + 1) Q0 = KeepImplicants (P 0; fxk ) Q1 = KeepImplicants (P 1; fxk ) in return Q0 [ Q1 [ (fxkg (P 0 n Q0)) [ (fxk g (P 1 n Q1)); Figure 2. The Algorithm PrimeCover . Proof. The proof is made using induction on k. The terminal cases are obvious: the constant function 0 has no prime implicant and the functions 1 and have the unique prime implicant 1. The sets of products Q0 and Q1 are sets of prime implicants of f that do not contain the variable xk . The set fxk g (P 0 n Q0) (respectively fxk g (P 1 n Q1)) is a set of prime implicants of f that contains the literal xk (respectively xk ), and that cover the set fxk n fxk (respectively fxk n fxk ). Lemma 1 guarantees that the set Q0 is made of prime implicants of fxk ^ fxk , and so of f , and the prime implicants of this set are sucient to cover all the elements of fxk that have not yet been covered using the prime implicants of the set P 0 n Q0. Since the same is true about Q1 with respect to fxk , the resulting set of prime implicants is a cover of the function f . 2 The number of recursions necessary to compute PrimeCover (f; 1) is equal to the number of vertices of the BDD of f , thus the cost of the algorithm PrimeCover is in O(jf j). However to this cost must be added the cost of applying, at each recursion, the function KeepImplicants , which explains (see Section 6) that in somes cases, the time needed to compute a prime cover of a function using the function PrimeCover is greater than the time needed to compute all its prime implicants using the algorithm described in [6].
4 Irredundant Prime Cover Computation This section presents the irredundant prime cover computation algorithm IrrCover . The cost of this algorithm is higher than the cost of the prime cover computation procedure presented in the previous section, but the prime cover it generates is of better quality, since it is irredundant. This algorithm is based on the recursive computation scheme proposed by E. Morreale in [20] that makes use of a divide and conquer strategy based on Shannon decomposition to compute the 3 subsets composing the canonical decomposition of the computed irredundant prime cover with respect to the variable xk .
Theorem 2 Consider an incompletely speci ed Boolean function f from f0; 1gn into f0; 1; g. The call IrrCover (f 1 ; f 1 ; 1) of the following algorithm produces an irredundant prime cover of the Boolean function f .
3
function IrrCover (f 1; f 1 : BooleanFunction ; k : int) : SetOfProducts ; if f 1 = 0 return ; if f 1 = 1 return f1g; let g0 = fx1k ^ :fx1k
P 0 = IrrCover (g0; fx1k ; k + 1) S c0 = p2P 0 p g1 = fx1k ^ :fx1k P 1 = IrrCover (g1; fx1k ; k + 1) S c1 = p2P 1 p h1 = (fx1k ^ :c0) _ (fx1k ^ :c1) h1 = fx1k ^ fx1k P = IrrCover (h1 ; h1; k + 1) in return P [ (fxk g P 0) [ (fxk g P 1); Figure 3. The algorithm IrrCover . Proof. The proof is made using induction on the number of variables of f . The function f 1 represents the set of elements of f0; 1gn that have to be covered, and the function f 1 represents the set of elements that can be used to build the largest possible cubes. If the function f 1 is equal to 0, there are no elements to be covered so the irredundant prime cover is empty. If the function f 1 is not 0 and f 1 is the function 1, then the irredundant prime cover made of the product 1 is sucient to cover f 1 . 1
fx
k
1*
1
fx* k
xk
1*
fx
k
1* xk
g1
1
fx
g0
1
h
c1
1*
c0
h Figure 4. Recursive computation of an irredundant prime cover. Every prime implicant of the irredundant prime cover P 0 contains at least one element of fx1k that is not in fx1k . Lemma 1 states that none of these prime implicants can be a prime implicant of f , so the literal xk must be added to each of these prime implicants in order to produce prime implicants of the function f . The same reasoning can be done for the prime implicants of the set P 1. The elements of f0; 1gn?1 that still have to be covered are in the set h1. This set if the union of the set (fx1k ^ :c0), that contains all the elements of fx1k that are not covered by any prime implicant of the set P 0, and of the set (fx1k ^ :c1), that contains all the elements of fx1k that are not covered by any prime implicant of the set P 1. The set h1 is included in the set h1, which is the subset of f0; 1gn?1 that can be used to build the largest possible cubes that cover the elements of h1. The products of the set P compose an irredundant prime cover of the function de ned by h1 and h1 , and this set is the last part of the canonical set decomposition of the computed irredundant prime cover. 2 4
The algorithm IrrCover has a cost in O(2jf j ) because at each recursion it can be necessary to create vertices. However experiences show that this algorithm is quite robust since it has been able to produce irredundant prime covers for all the functions of the MCNC benchmark [28].
5 Minimal Prime Cover Computation The minimal prime cover computation problem, also known as the 2-level logic minimization problem, has been devoted a lot of e orts since its de nition by Quine in 1952 [21]. It consists of nding a minimal cardinality subset of the set of prime implicants of a Boolean function f that is sucient to cover f . This section presents the concepts used in a new BDD and CS based minimization procedure.
5.1 Reduction of Set Covering Problems A set covering problem is a triple hX; Y; R i, where X and Y are two sets, and R be a relation de ned on X Y . We say that y covers x when xRy. The set covering problem hX; Y; R i consists of nding a minimal cardinality subset of Y that cover all the elements of X . We say that two set covering problems are equivalent if a minimal solution of one problem can be built with a minimal solution of the other problem. We present rst present the reduction rules for iteratively reducing a set covering problem to its cyclic core [17], and then introduce an alternative to this reduction processes that takes full advantage of the CS based sets of products manipulations.
5.1.1 Dominance Relations A quasi order on a set Z is a re exive and transitive relation de ned on Z Z . The relation is de ned by (z z 0) , ((z z 0 ) ^ (z 0 z )). It is an equivalence relation on Z , so is a partial order on Z= . Let hX; Y; R i be a set covering problem. The dominance relations X and Y are de ned as follows on X and Y respectively:
x X x0 , (8y 2 Y (x0Ry) ) (xRy)) y Y y0 , (8x 2 X (xRy) ) (xRy0 )) When an element y0 dominates y but the converse it not true, we will say that y0 strictly dominates y. and it will be noted y y0 . Dominance relations, that are quasi orders, can be used to reduce the size of a sets X and Y [17]. An element x0 of X dominates x i covering x0 is sucient to cover x, so x can be removed from X without modifying the set of minimal solutions. This is a bit di erent with elements of Y . The element y0 of Y dominates y i y0 covers at least all the elements of X covered by y. However, it is not true that removing y from Y does not modify the set of minimal solutions, even if y0 covers at least on element of X not covered by y, i.e., if y0 strictly dominates y. Some minimal solutions using y can be lost, but it still exists a minimal solution that uses y0 . For instance, if y and y0 cover the same elements of X , i.e. y Y y0 , then y and y0 can be chosen equivalently to build a minimal solution, provided that y and y0 are not strictly dominated by another element of Y . These elimination processes can be formalized by the following theorem. Theorem 3 The set covering problem hX; Y; R i is equivalent to the following ones: hmax (X= X ); Y; R i X hX; max (Y= Y ); R i Y
In this formulation, the relation R is modi ed in the usual way on the quotient sets.
Note that these problems are equivalent to hmaxX (X= X ); maxY (Y= Y ); R i, which is the smallest one, and so can be said to be the \simplest" problem amongst these 4 equivalent set covering problems. 5
5.1.2 Essentiality
The third reduction rule is based on the essentiality concept. An element y of Y is essential i it is the only one that covers an element x of X . Essential elements belong necessarily to any minimal solution. So problems hX; Y; R i and hX n fx 2 X j 9y 2 E xRyg; Y n E; R i, where E is the set of essential elements of Y , are equivalent.
5.1.3 Cyclic Core The cyclic core of hX; Y; R i is the xpoint obtained after the 3 reduction processes presented above
(dominance relations on X and Y , and essentiality) have been iteratively applied. In the case when this cyclic core is empty, the minimization is done, and the minimal prime cover is composed of the essential prime implicants that have been successively discovered. In the other case, the minimization can be terminated using a branch-and-bound algorithm [2, 17, 25].
5.2 Transposing Functions In the Quine-McCluskey procedure and its optimizations [2, 17, 22, 25, 27], the classes of the partitions X= X and of Y= Y are manipulated through projections X and Y that map each class onto one of its elements. This section shows that, instead of using such projections, one can use an isomorphism that maps the classes that must be manipulated on objects whose manipulation is less costly. De nition 1 Let be a quasi order on Z . The function de ned on Z is a transposing function of i z z 0 is equivalent to (z ) (z 0). In this case, (Z= ; ) and ( (Z ); ) are isomorphic through . (Z= ; ) ?! max (Z= ) % ?1
(Z; ) &
x ? y
x ? y
( (Z ); ) ?! max (Z ) Using the concept of transposing function, one can reformulate the set covering problem hX; Y; R i. Theorem 4 Let X and Y be two transposing functions of X and Y respectively. Then hX; Y; R i is equivalent to:
hmax (X ); max (Y ); R0 i X Y where R0 is de ned by X (x)R0 Y (y) , xRy. The relation R0 is well de ned thanks to the de nition of transposing functions.
5.3 The Minimization Procedure The idea of this minimization procedure consists of transposing the 2-level logic minimization problem hf; P; 2i into a set covering problem hQ; P; i that involves products and the subset relation. Two transposing functions Q and P of the associated dominance relations Q and P are de ned so that the reduction process described Section 5.2 transposes into a set covering problem that still involves products and the subset relation. This minimization procedure takes full advantage of the BDD and CS representations. This is done through the use of the functions Q and P compatible with Q and P respectively. These functions map the sets Q and P de ning the set covering problem onto sets of products. This means that the set covering problem matrix involes only products, and thus it can be eciently represented with CSs. This procedure allows us to compute cyclic cores of Boolean functions without computing the dominance relations, whose huge BDDs are the bottleneck of the previously available implicit cyclic core computation procedures [27]. The rst step in the procedure consists of computing the CS of the set of prime implicants P of the function f to be minimized using the algorithm presented in [6]. Then the set covering problem hf; P; 2i is transposed into a set covering problem hQ; P; i, where Q and P are sets of products represented by 6
CSs. The section then presents the functions Q and P compatible with Q and P respectively. It also shows how the essential products of P are easily computed using max Q (Q). Finally the section gives the complete cyclic core computation algorithm and emphasizes the key points that make it much more ecient that any other one.
5.4 Transposing the Minterms on Pn The rst transformation consists of nding a set covering problem hX; Y; R i equivalent to hf; P; 2i, where X and Y are sets of products and R = . Let Q be the set of the products that represent all minterms of f . Then hf; P; 2i is equivalent to hQ; P; i, where Q = fq 2 Pn j 9x 2 f fxg = qg
5.5 The Transposing Function Q After the transformation described above, we have to solve a set covering problem hQ; P; i, where Q and P are sets of products. The dominance relation Q is: q Q q0 , (8p 2 P (q0 p) ) (q p)) Theorem 5 The following function Q de ned from Q into Pn is a transposing function of Q. T Q (q) = fp2P jqpg p Proof. By de nition, we have: q Q q0 , (8p 2 P (q0 p) ) (q p)) , fp 2 P j q0 pg fp 2 P j q pg ) (Tfp2P jqpg p) (Tfp2P jq0 pg p) ) Q (q) Q (q0 ) Conversely, assume that Q (q) Q (q0 ). Since it is always true that q Q (q), we deduce that q Q (q0 ). By de nition of Q , this means that all products of P that contain q0 also contain q, i.e., q Q p0. 2
5.6 Essential Products The following result shows that the essential elements of P can be directly obtained from max Q (Q). Theorem 6 Let hQ; P; i be a covering matrix, where Q is a set of products, and P a maximal set of products. Then the set of essential products is P \ max Q (Q). Proof. Since P is maximal, P \ Q (Q) is equal to P \ max Q (Q). The product p is essential i it is the only one of P that contains a product q of Q. This implies that Q (q) = p. Conversely, assume that there exists a product q of Q such that Q (q) = Tp with p 2 P . Then if it exists p0 such that p0 6= p and p0 2 fp 2 P j q pg, we have p = Q (q) = ( fp2P jqpg p) p0, which is impossible because P is maximal. 2
5.7 The Transposing Function P Once the set of products Q0 = max Q (Q) has been for the set covering problem hQ; P; i, we obtain the new equivalent set covering problem hQ0 ; P; R0 i, with q0 R0 p i q0 = Q (q) and q p, as said in Section 5.2. It is easy to check that q p is equivalent to Q (q) p. This implies that the relation R0 is the subset relation, and so the new set covering problem is hQ0; P; i, that has exactly the same form as the rst one. The dominance relation on P is de ned by: p P p0 , (8q 2 Q (q p) ) (q p0)): Let us de ne the function C : 2f0;1gn ! Pn as follows: C (E ) = min fp 2 Pn j p E g: In other words, C (E ) is the smallest product that contains the set E . The product C (E ) is unique, because if we assume that there exist two di erent minimal products p and p0 that contain E , then p \ p0 is a smaller product that still contains E . We nally de ne the following transposing function P . 7
Theorem 7 The following function P de ned from P into Pn is a transposing function of P .
P (p) = C (Sfq2Qjqpg q) Proof. Let p and p0 be two products of P . By de nition, we have: p P p0 , (8q 2 Q (q p) ) (q p0 )) , fq 2 Q j q pg fq 2 Q j q p0g ) (Sfq2Qjqpg q) (Sfq2Qjqp0 g q) ) P (p) P (p0 ) because the function C is increasing. Conversely, assume that P (p) P (p0 ). Since P (p) p is always true, we deduce P (p) p0. Also we have by de nition q P (p) for all q of Q that are contained by p. Finally, this means that all q of Q contained by p are also contained by p0 , i.e., p p0. 2
5.8 The Final Algorithm The advantage of the transposing functions Q and P is that their range are Pn, and so max Q (Q) and max P (P ) are sets of products that can be eciency represented with CSs. Ecient algorithms that directly compute these sets without building the BDDs of the dominance relations can be found in [10]. Finally, the new algorithm consists of implicitly computing the cyclic core of f by applying transformation 0 once, hf; P ; 2i !0 hffxg j x 2 f g; P ; i where the CS P of all the prime implicants of the function f to be minimized is computed using the algorithm presented in [6], and then by iteratively applying the following ordered transformations: hQ; P ; i !1 hmax (Q); P ; i Q
hQ; P ; i !2 hQ ^ :E ; P ^ :E ; i with E = P ^ Q hQ; P ; i !3 hQ; max (P ); i P
Transformation 0 consists of transposing the 2-level logic minimization problem into an equivalent set covering problem hQ; P ; i, where Q and P are sets of products. Transformation 1 uses the transposing function Q to reduce the size of the problem. Transformation 2 consists of computing the CS E of the set of essential products of P , as shown in Section 5.6, since at this step Q is the CS of max Q (Q). Transformation 3 uses the transposing function P to produce the new set covering problem hQ; max P (P ); R0 i, with qR0 p0 i p0 = P (p) and q p, as said in Section 5.2. One can check that q P (p) is equivalent to q p, so the relation R0 is the subset relation, as said by transformation 3. The key points of this algorithm are: the use of BDDs and CSs, that make its complexity independent of the number of minterms and prime implicants of f ; the use of transformation 0 that transposes the initial set covering problem into a new one using sets of products and the subset relation; the use of two transposing functions of the two associated dominance relations, whose ranges are set of products, allowing ecient manipulations of the sets of the new set covering problem using CSs. This procedure allows us to compute cyclic cores of Boolean functions without computing the dominance relations, whose huge BDDs are the bottleneck of the previously available implicit cyclic core computation procedures [27]. In the case when the cyclic core of the Boolean function f to be covered is empty, a minimal prime cover of f can be immediately built by choosing, for each of the essential elements that have been discovered during the xpoint computation, a prime implicant of f , with a minimal number of literals, that contains it. The resulting prime cover thus has a minimal number of prime implicants and of literals. In the case when the cyclic core of the Boolean function f to be covered is not empty, the minterms of f that still have to be covered are all the ones that are not covered by any of the prime implicants of f that have been chosen to cover the essential elements, and the set of prime implicants that can be used to cover them are any subset of the set of prime implicants of f that are sucient to contain all the products P of the cyclic core. A call to the algorithm IrrCover produces an irredundant prime cover of these minterms that is added to the already selected prime implicants to compose a locally minimal prime cover of f . Research is under way to develop a branch and bound minimization algorithm based on Bdds and CSs. 8
6 Experimental Results Table 1 and Table 2 present the experimental results that have been obtained using the di erent prime cover computation algorithms presented in this paper. Column \#Vars" of Table 1 gives, for each of the treated examples, the number of variables of the function to be covered, and column \j f j" the size of the BDD that represents this function. For each prime cover computation with method M , \#M" gives the number of elements of the prime cover, \jMj" gives the size of the CS that represents this cover, and \TM" the CPU time in seconds to compute it on an DEC3000 machine. Method AP computes all the prime implicants using the algorithm presented in [6], method PC computes a prime cover using algorithm PrimeCover , method IPC computes an irredundant prime cover, and MC a minimal prime cover using the algorithm presented in Section 5. A \" in the column \#MPC" indicates that the cyclic core of the Boolean function under treatment was empty so that it was not necessary to use the irredundant prime cover algorithm to terminate the generation of the minimal prime cover.
f
alupla cont bc0 bench1 ex1010 ex5 signet x7dn xparc ibm prom1 prom2 mish pdc ti jbp
#Vars j f j #AP j AP j TAP #PC j PC j TPC 18 5044 25678 14983 9:1s 16013 9508 19:0s 58 1970 17060286 3818 1:0s 13209292 3217 3:1s 37 968 6597 7388 4:3s 238 625 0:6s 18 1438 5972 7804 3:6s 443 1251 0:9s 20 2761 25889 28831 15:7s 978 2392 2:0s 71 1817 2532 7984 2:1s 165 785 0:4s 47 14681 78735 37535 64:5s 13067 10672 144:5s 81 3124 566698632 39960 11:7s 123604088 4613 6:0s 114 7883 15039 18798 6:8s 4457 4413 3:9s 65 2080 1047948792 5345 1:5s 819466504 3305 3:5s 49 8359 9326 24358 11:7s 558 4071 3:5s 30 4342 2635 9208 3:4s 319 2016 1:6s 137 2937 1:12437 e +15 2435 1:0s 1:12437 e +15 2476 6:5s 56 2878 23231 11695 5:6s 2688 2796 2:9s 119 9188 836287 9230 3:8s 284985 5975 5:8s 93 11224 2496809 44638 15:2s 581823 14714 21:2s Table 1. Exhaustive Prime Implicant and Prime Cover Computation Results.
f
#IPC j IPC j TIPC #MPC j MPC j TMPC 2144 2752 12:2s 2144 2752 76:5s 317 672 1:6s 229 603 6:0s 292 1081 3:1s 177 658 35:3s 200 946 0:8s 162 867 32:3s 496 1980 2:7s 456 1978 343:9s 89 1170 1:5s 87 1147 111:2s 121 390 8:3s 119 382 248:5s 622 725 2:9s 622 651 75:3s 307 4827 5:0s 254 3853 38:2s 173 426 0:9s 173 426 6:3s 609 6038 6:4s 472 3997 83:1s 476 3583 3:1s 446 3463 105:2s 82 296 0:9s 82 296 5:2s 272 1864 2:4s 156 1174 91:3s 377 2579 3:5s 220 2388 39:6s 129 1631 4:0s 130 1568 70:0s Table 2. Irredundant and Minimal Prime Cover Computation Results.
alupla cont bc0 bench1 ex1010 ex5 signet x7dn xparc ibm prom1 prom2 mish pdc ti jbp
These tables show that in all cases the sizes of the prime covers generated using the algorithms presented here are much smaller than the numbers of prime implicants of the Boolean functions under treatment, and that in most cases they provide users with a very concise representation of the function under treatment. In all cases the CPU times needed to compute the minimal prime covers are larger than the CPU times needed to compute the irredundant prime covers, though these irredundant prime covers are in most cases nearly as good as the minimal prime covers. 9
7 Conclusion In this paper we have presented a uni ed set of algorithms dealing with implicit prime cover computation. Given the BDD of a Boolean function, the graph representation of all its prime implicants, of a prime cover, of an irredundant prime cover, and of a minimal prime cover, is computed with a complexity not related with the number of products to be manipulated. The eciency of these algorithms have been demonstrated by treating functions that are out of reach of any other known technique. Applications of these algorithms to speci c problems will be presented in a forthcoming paper.
References [1] S. B. Akers, \Binary Decision Diagrams", IEEE Trans. on Computers, Vol 27, pp. 509{516, 1978. [2] R. E. Brayton, G. D. Hachtel, C. T. McMullen, A. L. Sangiovanni-Vincentelli, Logic Minimization Algorithms for VLSI Synthesis, Kluwer Academic Publishers, 1984. [3] R. K. Brayton, P. C. McGeer, J. Sanghavi, \A New Exact and Heuristic Minimizer for Two-Level Logic Synthesis", in Proc. of Int'l Symposia on Information Sciences, Fukuoka, Japan, July 1992. [4] R. E. Bryant, \Graph-Based Algorithms for Boolean Functions Manipulation", IEEE Trans. on Computers, Vol C35, N0 8, pp. 677{692, August 1986. [5] R. E. Bryant, \Symbolic Boolean Manipulations with Ordered Binary Decision Diagrams", ACM Computing Surveys, Vol 24, N0 3, pp. 293{318, September 1992. [6] O. Coudert, J. C. Madre, \Implicit and Incremental Computation of Primes and Essential Primes of Boolean Functions", in Proc. of 29th DAC, Anaheim CA, USA, June 1992. [7] O. Coudert, J. C. Madre, \A New Graph Based Prime Computation Technique", in New Trends in Logic Synthesis, T. Sasao Editor, Kluwer Academic Publishers, 1992. [8] O. Coudert, J. C. Madre, \Towards a Symbolic Logic Minimization Algorithm", in Proc. of VLSI Design'93, Bombay, India, January 1993. [9] O. Coudert, J. C. Madre, \Fault Tree Analysis: 1020 Prime Implicants and Beyond", in Proc. of Annual Reliability and Maintainability Symposium, pp. 240{245, Atlanta GA, USA, January 1993. [10] O. Coudert, J. C. Madre, H. Fraisse, \A New Viewpoint on Two-Level Logic Minimization", in Proc. of 30th DAC, Dallas TX, USA, June 1993. [11] R. B. Cutler, S. Muroga, \Useless Prime Implicants of Incompletely Speci ed Multiple-Output Switching Functions", in Int'l Journal of Computer and Information Sciences, Vol. 9, No. 4, 1980. [12] J. Doyle, \A Truth Maintenance System", in Arti cial Intelligence, 12:231-271, 1979. [13] D. F. Hasl, \Advanced Concepts in Fault Tree Analysis", in Proc. of System Safety Symposium, Seatle, USA, Juin 1965. [14] S. J. Hong, S. Muroga, \Absolute Minimization of Completely Speci ed Switching Functions", in IEEE Trans. on Computers, Vol 40, pp. 53{65, 1991. [15] J. De Kleer. An Assumption-based TMS. Arti cial Intelligence, 28:127-162, 1986. [16] J. De Kleer, B. C. Williams, \Diagnosing Multiple Faults", in Arti cial Intelligence, Vol 32. pp. 97{ 130, 1987. [17] E. L. Jr. McCluskey, \Minimization of Boolean Functions", in Bell System Techniques, Vol 35, pp. 1417{1444, 1959. [18] J. C. Madre, O. Coudert, \A Logically Complete Reasoning Maintenance System Based on Logical Constrain Solver", in Proc. of IJCAI'91, Sydney, Australia, August 1991. [19] S. Minato, \Zero-Supressed BDDs for Set Manipulation in Combinatorial Problems", in Proc. of 30th DAC, Dallas TX, June 1993. [20] E. Morreale, \Recursive Operators for Prime Implicant and Irredundant Normal Form Determination", IEEE Trans. on Computers, 1970. [21] W. V. O. Quine, \The problem of Simplifying Truth Functions", in American Mathematics Monthly, Vol. 59, pp. 521{531, 1952. [22] W. V. O. Quine, \On Cores and Prime Implicants of Truth Functions", in American Mathematics Monthly, Vol. 66, 1959. 10
[23] R. Reiter, J. de Kleer, \Foundations for Assumption-Based Truth Maintenance Systems" in Proc. of AAAI Nat'l Conference'87, pp. 183-188, Seattle, July 1987. [24] R. L. Rudell, Multiple-Valued Logic Minimization for PLA Synthesis, UCB Report M86/65, 1986. [25] R. L. Rudell, A. L. Sangiovanni-Vincentelli, \Multiple Valued Minimization for PLA Optimization", in IEEE Trans. on CAD, Vol 6, No 5, pp. 727{750, September 1987. [26] T. Sasao, \An Application of Multiple-Valued Logic to a Design of Programmable Logic Arrays", Proc. of Int'l Symposium on Multiple-Valued Logic, 1978. [27] G. M. Swamy, P. McGeer, R. K. Brayton, \A Fully Quine-McCluskey Procedure using BDD's", Report #UCB/ERL M92/127, November 1992. Also in Proc. of Int'l Workshop on Logic Synthesis, Lake Tahoe CA, May 1993. [28] S. Yang, Logic Synthesis and Optimization Benchmarks User Guide, Microelectronics Center of North Carolina, January 1991.
11
