Using Symbolic Techniques to find the Maximum Clique in Very Large Sparse Graphs

Transcription

1 Using Symbolic Techniques to find the Maximum Clique in Very Large Sparse Graphs Fulvio CORNO, Paolo PRINETTO, Matteo SONZA REORDA Politecnico di Torino Dipartimento di Automatica e Informatica Torino, Italy Abstract * Several problems arising in CAD for VLSI, especially in logic and high level synthesis, are modeled as graph-theoretical problems. In particular, minimization problems often require the knowledge of the cliques in a graph. This paper presents a new approach for finding the maximum clique in realistic graphs. The algorithm is built around a classical branch-and-bound, but exploits the efficiency of Binary Decision Diagrams and Symbolic Techniques to avoid explicit enumeration of the search space. The approach is proven to be more efficient than classical algorithms, which suffer from the enumeration problem, as well as than purely symbolic implementations, which suffer from the explosion in the size of BDDs. As a result, we are able to compute the maximum clique without introducing approximations for graphs with billions of vertices and transitions. 1. Introduction The importance of efficient algorithms for solving several problems in Graph Theory has been recognized since many years by researchers involved in VLSI CAD. Finding the maximum clique in a graph is an important problem in many areas, like layout [16], testing [11], optimization [19], and synthesis [18] [3]. The problem is NP-complete [12], but efficient heuristics have been found [1] [9]. Unfortunately, when graph size increases, they all sufer form the enumeration problem, since the size of the data structure and the complexity of many elementary operations is at least linear in the size of the graph: this usually prevents the graph from even being represented in memory. On the other hand, the last years have seen the development of techniques for Boolean functions repre- * Contact address: Paolo Prinetto, Dipartimento di Automatica e Informatica, Politecnico di Torino, Corso Duca degli Abruzzi 24, I Torino TO (Italy), Paolo.Prinetto@polito.it sentation and manipulation based on Binary Decision Diagrams (BDDs) [6]. It is now possible to handle complex functions of a large number of variables with acceptable memory and CPU time requirements [4]. We presented a direct approach to solve the maximum clique problem resorting to BDDs in [8]. In that work, a Boolean function encoding all the completely connected components in a graph was computed and the maximum clique was deduced by traversing the BDD representing the function. Severe limitations appeared when the size of the graph or its density were increased, since the computed function required a Boolean variable for each node in the graph, and no known heuristic for variable ordering is able to give satisfactory results when several thousands of variables are involved. Most symbolic algorithms thus suffer from an encoding problem, where one ends up with an intractable number of BDD nodes when trying to encode as a Boolean function all the possible solutions to avoid enumeration. To solve this problem, several approaches have been proposed, ranging from dynamic variable orderings [20] to ad-hoc BDD variants especially suited for encoding sets of objects [17]. Thus, when very large graphs are considered, neither traditional implementations, due to the enumeration problem, nor purely symbolic approaches, due to the encoding problem, are able to find a solution. The goal of this paper is to present a new approach where symbolic manipulations are interspersed with more traditional branch-and-bound computations, allowing us to find a good trade-off between enumeration and encoding. Moreover, heuristics originally developed for traditional implementations can be adopted, while this is not true in purely symbolic approaches. The paper is organized as follows: Section 2 presents the algorithm for the maximum clique problem, as well as an improved version exploiting heuristics to speed-up the computations. Section 3 reports some experimental results showing the applicability of the

2 approach to very large graphs, and Section 4 draws some conclusions. 2. Finding a Maximum Clique Let us consider an undirected graph G = (V, E) composed of a set V of vertices v and a set E V V of edges e = (v i, v j ). A clique in G is a maximal completely connected sub-graph, identified by the subset C V of vertices such that: v i, v j C, (v i, v j ) E. Finding the maximum clique in a graph is an NPcomplete problem [14]. Rich literature exists on resolving algorithms: in [5] a basic branch-and-bound technique is presented; chordal graphs, starting from [13], are exploited in [1]; a simple but efficient enumerative algorithm is presented in [7], while [10] uses an algorithm based on Tabu Search. A naive branch-and-bound algorithm [14] is in Fig. 1. The recursive procedure is invoked on the graph as search( V, 0 ). The bounding condition computes an upper bound on the size of the clique contained in a sub-graph by counting the nodes in the subgraph Symbolic branch-and-bound The algorithm in Fig. 1, when implemented resorting to traditional techniques and applied to very large graphs, suffers from the following inefficiencies: the graph, and in particular its adjacency relation E, are inherently difficult to store when millions or billions of vertices are considered; sets of vertices R and R need to be represented, wasting significant amounts of memory; the computation of R, the set of vertices adjacent to v and internal to R requires O( V ) operations. Symbolic Techniques can be used to overcome these limitations, making a very simple algorithm applicable to huge graphs with little effort. The adopted technique is quite standard, and resorts to the adoption of characteristic functions to represent sets and relations [2], once vertices are given an arbitrary Boolean encoding. Characteristic functions are Boolean functions, therefore they can be represented by BDDs and efficiently operated on by specialized Boolean operators. With Symbolic Techniques, the three problems listed above can be solved as follows: the graph is represented by the characteristic function of its adjacency relation E: χ E (v, v ) = 1 iff (v, v ) E, else 0; (1) sets of vertices, e.g., R, are represented by their characteristic functions: χ R (v) = 1 iff v R, else 0; (2) the computation of the set R of vertices adjacent to R (statement 6 in Fig. 1) is accomplished as: χ R (v ) = v [χ R (v) χ E (v, v ) (v v)]. (3) search( set_of_vertices R, int nesting ) { vertex v, v ; set_of_vertices R ; 1: if( R = ) 2: max_clique = { marked vertices } ; /* its size is nesting */ 3: else 4: for( each vertex v R ) 5: { mark( v ) ; 6: R = { vertices R adjacent to v } ; 7: if( nesting R > max_clique ) /* bounding condition */ 8: search( R, nesting+1 ) ; 9: unmark( v ) ; 10: delete v from R ; } } Figure 1: Branch-and-bound algorithm The adoption of the above representations for the graph and for sets of vertices allows us to deal with very large graphs. When the algorithm is run, its time complexity proves still too high since it consists of a nearly exhaustive search: the adopted bounding condition is not effective since it overestimates the size of the maximum clique contained in a subset of vertices by assuming that subgraphs are complete. To improve the accuracy of the bounding condition, limiting the search space, we adopted a well known heuristic, based on an approximate coloring of the graph. The next two sections explain how an approximate coloring can be symbolically computed, and how this information is exploited to improve the performance of the algorithm Approximate graph coloring Graph coloring associates each vertex a color such that no two adjacent vertices have the same color and that the number of different colors is minimum. The number of necessary colors is an upper bound on the size of the maximum clique in a graph (or subgraph). Finding an exact graph coloring is by itself a NPcomplete problem. Since in this context it will be used solely for improving a bounding condition, an approximate but cheaper solution suffices, where the number of colors needs not be minimum. A classical greedy algorithm for approximate graph coloring considers one vertex at a time, and associates it the lowest-

3 numbered color which is not associated to any of its adjacent vertices: this approach is unacceptable since it requires to consider all the possible vertices. A symbolic approach needs to be developed, where sets of vertices are considered and colored in parallel. The followed approach is summarized in Fig. 2, where for each color a set of independent vertices are computed and are given that color. The association of colors to vertices is encoded by the following characteristic function: χ col (v, c) = 1 iff v is colored with color c, else 0. (4) Resorting to (4), the coloring of vertices in N with col (statement 4) is: χ col (v, c) = χ col (v, c) + [χ N (v) (c = col)]. (5) color( adjacency_relation E ) { vertex v ; set_of_vertices N, N ; 1: N = V ; col = 1 ; do { /* select N N such that N is an independent set */ 3: N = independent_subset( E, N ) ; 4: color all vertices in N with col ; 5: N = N N ; col ++ ; 7: } while ( uncolored vertices exist ) ; } Figure 2: Approximate graph coloring The operation to consider is the selection of the subset N N (statement 3) such that vertices in N are independent (i.e., no two vertices in N are adjacent to each other). This task is more complex since the solution is not unique, involving some choices to be made: when two vertices in N are adjacent, only one should appear in N. To select the vertex to keep, we consider a total ordering on vertices based on their numerical encoding, and represent the ordering relation with its characteristic function χ > (v, v ) defined as: χ > (v, v ) = 1 iff v > v, else 0. (6) Using the ordering relation, a directed acyclic graph (DAG) is induced: in the DAG, for each couple of dependent vertices we choose the smaller one in the ordering. The idea is formalized in Fig. 3, which shows the algorithm used for the selection of the independent subset N. Vertices that have no predecessors (statement 3) are computed as: χ H (v )=χ N (v ) v [χ > (v, v ) χ E (v, v ) χ N (v)], (7) while successors of H (statement 5) are: v [χ H (v) χ E (v, v )]. (8) The number of iterations of the algorithm (i.e., the number of levels of the DAG) is generally much smaller than the size of the resulting set N since at each iteration several vertices are added at once. set_of_vertices independent_subset (adjacency_relation E, set_of_vertices N) { set_of_vertices N ; adjacency_relation E > ; 1: N = ; 2: E > = E (v > v ) ; do { 3: H = { vertices with no predecessor } ; 4: N = N H ; 5: N = N H { successors of H in E }; 6: } while (N ) ; 7: return N ; } Figure 3: Selection of an independent subset N N 2.3. Improved algorithm The previous sub-section showed how to compute an approximate coloring for a graph without explicitly considering every vertex. The information gathered by the procedure is encoded by the characteristic function of the vertex coloring relation, χ col (v, c). This new information is exploited to improve the bounding condition, by estimating the maximum clique in a subgraph with the number of different colors it contains. The bounding condition in Fig. 1 is thus modified according to Fig. 4. 7: if( nesting num_colors_in(r ) > max_clique ) Figure 4: Improved bounding condition The number of colors in a subgraph is computed as: num_colors_in(χ R (v)) = on_set( v[χ R (v) χ col (v, c)] ). (9) The effect of the improved bounding condition is to prune the search tree by giving an accurate upper bound of the clique size in a subgraph. 3. Experimental Results The algorithms described in the previous section were implemented using the BDD package developed at our institution. They amount to less than 1,000 C source code lines. Experiments were run on a Sun

4 SparcStation 2 with 32MB RAM, with a limit of 1,000,000 BDD nodes set. Our purpose was to test the algorithms on very large graphs, with characteristics typical for problems found in the area of VLSI. For this reason we chose to work on the state transition graphs of the standard ISCAS 89 benchmark circuits. The adjacency relation χ E among states has been extracted from the topological description of each circuit. Tab. 1 shows the sizes of the graphs and proves that the BDD data structure is orders of magnitude smaller than the explicit representations. Tab. 2 reports the results obtained in finding the maximum clique in the above graphs. The number of colors used in the approximate coloring of the graph is also reported, and CPU times (in seconds) are shown for both graph coloring and for the branch-and-bound search. Efficiency depends much more on the accuracy of the upper bound than on the size of the graphs. In Tab. 3, a comparison is reported between our mixed symbolic-explicit approach and two other implementations, ran on the same hardware: [8], where a purely symbolic algorithm is adopted, suffers from the necessity of representing BDDs with an enormous number of variables and can be applied for the smallest benchmarks, only; [1], one of the state-of-the-art traditional implementations, exhibits comparable run times on smaller examples but fails to deal with larger graphs due to the memory required by data structures; the basic algorithm presented in this paper is able to work on all the benchmark circuits, since memory allocation with BDDs is more efficient, but run times are unacceptably high due to the nearly exhaustive nature of the search. Only experiments that terminate in less than 10 CPU hours are reported; the effect of the approximate coloring is evident, since CPU times are reduced by orders of magnitude even on the largest graphs. The only experiments that did not complete in 10 hours are s1196 and s1238, due to the looseness of the upper bound. 4. Conclusions A new approach for solving the maximum clique problem in undirected general graphs has been presented. The problem has been solved resorting to a mixed symbolic-explicit approach, taking advantages from both the computational efficiency of BDDs and the clever heuristics that have been developed for traditional algorithms, which allowed us to deal with billions of vertices. Our approach proved effective in finding the maximum clique for the state transition graphs of most sequential benchmark circuits. Former approaches, both symbolic and heuristic, are shown to be unable to deal with such graphs. Current research includes the application of the same approach to other problems of relevant importance in CAD for VLSI, such as the clique covering problem, basis of most minimization algorithms. Acknowledgments The authors wish to thank Dr. Federico Della Croce for the useful discussions and Silvia Chiusano for participation in the development and implementation of the algorithm. References [1] E. Balas, C. S. Yu: Finding a Maximum Clique in an Arbitrary Graph, SIAM Journal of Computing, Vol. 15, No. 4, November 1986, pp [2] J.R. Burch, E.M. Clarke, K.L. McMillan, D.L. Dill, L.J. Hwang: Symbolic Model Checking: 1020 States and Beyond, LICS 90: 5th Annual IEEE Symposium on Logic in Computer Science, June 1990, pp [3] R. K. Brayton, G. D. Hachtel, A. L. Sangiovanni- Vincentelli: Multilevel Logic Synthesis, Proceedings of the IEEE, Vol. 78, No. 2, February 1990, pp [4] K. S. Brace, R. L. Rudell, R. E. Bryant: Efficient Implementation of a BDD Package, DAC 90: 27th ACM/IEEE Design Automation Conference, pp [5] C. Bron, J. Kerbosch: Finding All Cliques of an Undirect Graph, Communications of the ACM, Vol. 16, No. 9, September 1973, pp [6] R. E. Bryant: Graph-Based Algorithms for Boolean Function Manipulation, IEEE Transactions on Computers, Vol. C-35, No. 8, August 1986, pp [7] R. Carraghan, P. M. Pardalos: An Exact Algorithm for the Maximum Clique Problem, Operations Research Letters, Vol. 9, 1990, pp [8] F. Corno, P. Prinetto, M. Sonza Reorda: Finding the Maximum Clique in a Graph Using BDDs, ICVC 93: IEEE 3rd International Conference on VLSI and CAD, Taejon, Korea, November 1993, pp [9] F. Della Croce, R. Tadei: A multi-kp modeling for the maximum clique problem, European Journal of Operational Research, Vol. 73, El-sevier, 1994, pp [10] C. Friden, A. Hertz, D. De Werra: TABARIS: an Exact Algorithm based on Tabu Search for Finding a Maximum Independent Set in a Graph, Computers Operations Research, Vol. 17, No. 5, pp , 1990 [11] M. Franklin, K. K. Saluja: Hypergraph Coloring and Reconfigured RAM testing, IEEE Transactions on Computers, Vol. 43, No. 6, June 1994, pp [12] M. R. Garey, D. S. Johnson: Computers and Intractability: A Guide to the Theory of NP-completeness, Freeman, 1979

5 [13] F. Gavril: Algorithms for Minimum Coloring, Maximum Clique, Minimum Covering by Cliques, and Maximum Independent Set of a Chordal Graph, SIAM J. of Computing, Vol. 1, No. 2, June 1972, pp [14] A. Gibbons: Algorithmic Graph Theory, Cambridge University Press, Cambridge (MA), USA, 1985 [15] S. W. Jeong, B. Plessier, G. D. Hatchel, F. Somenzi: Variable Ordering for Binary Decision Diagrams, EDAC 92: IEEE European Design Automation Conference, Brussels (Belgium), March 1992, pp [16] T. Lengauer: Combinatorial Algorithms for Integrated Circuit Layout, John Wiley & Sons, 1990 [17] S. Minato: Zero-Suppressed BDDs for Set Manipulation in Combinatorial Problems, DAC-93: 30th Design Automation Conference, pp [18] M. C. McFarland, A.C. Parker, R. Camposano: The High-Level Synthesis of Digital Systems, Proceedings of the IEEE, Vol. 78, No. 2, Feb. 1990, pp [19] R. Puri, J. Gu: Microword Length Minimization in Microprogrammed Controller Synthesis, IEEE Transactions on Computer-Aided Design, Vol. 12, No. 12, October 1993, pp [20] R. Rudell, Dynamic Variable Ordering for Ordered Binary Decision Diagrams, IWLS 93: International Workshop on Logic Synthesis, pp. 3a-1 3a-10 Circuit(s) Flip- Flops Number of Edges χ E size [BDD] s820, s s s s1488, s s s , s344, s ,116, s , s1196, s ,119, ,061 s641, s ,384,180 56,383 s382, s ,473,211 2,376 s ,473,211 2,190 s526, s526n 21 10,484,475 9,186 s > ,927 s > ,283 Table 1: Graph characteristics Circuit Max. Clique # Colors Color time Search time s820, s < 0.1 s < 0.1 s < 0.1 s1488, s < 0.1 s < 0.1 s s344, s s s1196 1,034 1, > 10 h s1238 1,046 1, > 10 h s641, s ,980 s382, s s s526, s526n ,363 s s Table 2: Algorithm results Circuit CPSo93 BaYu86 Without Coloring heuristics With Coloring heuristics s < 0.1 < s < 0.1 < s < 0.1 < s < 0.1 < s < s < s s s s s s > 10 h s > 10 h s ,035.0 s ,040.1 s s , s , s ,373.6 s526n ,829.6 s s Table 3: Comparison with other approaches