Decycling Bipartite Graphs

Let G = (V,E) be a graph and let S ⊆ V be a subset of its vertices. If the subgraph of G induced by V \ S is acyclic, then S is said to be a decycling set of G. The size of a smallest decycling set of G is called the decycling number of G. Determining the decycling number of a graph G is NP-hard, even if G is bipartite. We describe a tabu search procedure that generates decycling sets of small size for arbitrary bipartite graphs. Tests on challenging families of graphs show that the proposed algorithm improves many best-known solutions, thus closing or narrowing the gap to the best-known lower bounds.


Introduction
We consider the problem of eliminating all cycles from a graph by means of deletion of vertices. Determining a decycling set (i.e., a set of vertices whose removal eliminates all cycles) of minimum size is an NP-hard problem, even for bipartite graphs. We describe a heuristic procedure that produces small decycling sets in arbitrary bipartite graphs. Experiments performed on challenging families of bipartite graphs will demonstrate the efficiency of the proposed procedure. We first need to fix some notation to describe the problem more precisely.
Let G = (V, E) be a simple undirected graph with vertex set V and edge set E. The order of G is its number |V | of vertices. For a subset W ⊆ V of vertices, we write E(W ) for the set of edges of G with both endpoints in W , while G[W ] = (W, E(W )) is the subgraph of G induced by W . Also, we write N G (v) for the set of vertices adjacent to v in G and d G (v) = |N G (v)| is the degree of v. A stable set of G is a set of pairwise non-adjacent vertices, while a clique of G is a set of pairwise adjacent vertices. A forest is an acyclic graph. A graph G = (V, E) is bipartite if there is a partition (V 1 , V 2 ) of V so that all edges of E have one endpoint in V 1 and the other in V 2 , and we also write G = (V 1 , V 2 , E). For other basic notions of graph theory that are not defined here, we refer to Diestel [10]. Let W be a subset of vertices of a graph G = (V, E). If the induced subgraph G[V \ W ] of G is acyclic, then W is said to be a decycling set of G. The smallest size of a decycling set of G is the decycling number (or feedback vertex number) of G and is denoted by ϕ(G). Let φ(G) denote the largest order of an induced forest of G = (V, E). Clearly, determining ϕ(G) is equivalent to computing φ(G) since a subset F ⊆ V of vertices induces a forest in G if and only if V \ F is a decycling set of G, which implies ϕ(G) + φ(G) = |V |.
Determining the decycling number of a graph has various applications, including deadlock recovery [27], synchronous distributed systems [22], VLSI design [12], constraint satisfaction and Bayesian inference [4]. Karp [17] has shown that the problem is NP-hard, even when restricted to planar graphs, bipartite graphs and perfect graphs. On the other hand, the problem is known to be solvable in polynomial time for various other families of graphs, including cubic graphs [19,28], cocomparability graphs and convex bipartite graph [20]. A 2-approximation (i.e., a polynomial time algorithm that generates a decycling set of cardinality at most 2ϕ(G)) is described in [3], while a branch-and-cut algorithm for the exact solution of the problem is given in [8]. Local search algorithms are proposed in [8,9,23,26] for determining an upper bound on the decycling number of arbitrary graphs. More results on the decycling number can be found in [5].
In a seminal paper on the topic, Beineke and Vandell [7] have bounded the decycling number of hypercubes. Improving these bounds for hypercubes was continued in [6,13,25]. Other families of graphs have then also been investigated, including Fibonacci cubes [11], bubble sort graphs [30] and star graphs [29]. All these graphs are bipartite and have nice topological properties that provide attractive interconnection schemes for massively parallel systems [1,2]. The problem of avoiding deadlocks when using these topologies for exchanging data between processors can be reformulated as a decycling problem, and it turns out that computing the decycling number of these bipartite graphs is a real challenge. Indeed, there is a gap between the best-known lower and upper bounds on ϕ(G) for such graphs G with only 120 vertices. We aim to decrease these gaps by generating decycling sets of small size.
In the next section, we describe an algorithm that determines small decycling sets in arbitrary bipartite graphs. We first design in Section 2.1 a procedure that extends an induced forest G[F ] of G to a larger one G[F ′ =F ∪S] with a stable set S of G. We then show in Section 2.2 how to embed such forest extensions into a tabu search. In Section 3, we demonstrate the efficiency of our algorithm by applying it on various challenging families of bipartite graphs. The proposed procedures offer flexibility at different levels, and we will discuss this in Section 4.

The proposed algorithm
As a first observation, note that if a vertex set induces a forest in G, then all its subsets also induce a forest in G. As a particular case, assume that F is the vertex set of an induced forest of G and that S is obtained from F by removing all vertices of degree at least 2 in G[F ] as well as one vertex per connected component of G[F ] with exactly 2 vertices. Then S is a stable set of G, and G[F \S] is a forest of G obtained from G[F ] by removing all isolated vertices as well as some of its leaves. We show in Section 2.1 how to use this property the other way around. In other words, given a subset F that induces a forest in G, we will extend it to a larger set F ′ =F ∪S so that G[F ′ ] also induces a forest in G, while imposing that the set S of added vertices is a stable set of G.
Given a forest G[F ] of G, finding a set F ′ of maximum cardinality so that F ′ ⊇ F and G[F ′ ] is also a forest of G is a difficult task. Indeed, for F = ∅, the problem is equivalent to determining φ(G). We will focus on bipartite graphs G and on supersets F ′ of F obtained by adding a stable set S of G (i.e., F ′ = F ∪ S). These assumptions make the problem a little easier. Indeed, while finding a stable set of maximum cardinality in an arbitrary graph is an NP-hard problem, the famous Hungarian method [18] can be used when restricted to bipartite graphs. Hence, given a vertex set F that induces a forest G[F ] in a bipartite graph G = (V, E), the following problem can be solved in polynomial time: find a stable set S ⊆ V \ F of maximum cardinality such that every vertex in S is adjacent to at most one vertex in F . With such a stable set S we deduce that G[F ′ = F ∪ S] is a forest of G. It is obtained by adding leaves and isolated vertices to G[F ]. We will go one step further by considering stable sets S of G that possibly contain vertices with more than one neighbor in F .
The next subsection gives more details on the proposed procedure that extends an induced forest G[F ] of G to a larger one G[F ′ = F ∪ S] with a stable set S of G. The next step will be to embed these forest extensions into a tabu seach. Roughly speaking, we are going to explore the space that contains all the induced forests of G that have fixed numbers of vertices in X and in Y , and for each considered forest, we will try to extend it by adding a stable set of G. This will be explained in detail in Section 2.2.

Forest extensions with stable sets
Let F be the vertex set of an induced forest of a graph G = (V, E). Assume G[F ] has r connected components with vertex sets C 1 , C 2 , . . . , C r . We denote by V F the set of vertices v ∈ V \ F with at most one neighbor in every C i : Clearly, adding a vertex v / ∈ V F to F creates a cycle. We therefore extend F by choosing vertices in V F . We consider the partition (V ≤1 is the subset of vertices in V F with at most one neighbor in F and V ≥2 F is the subset of vertices in V F with at least two neighbors in F : For illustration, consider the bipartite graph G at the top left of Figure 1 and assume F = {a, f, g, h, j, n, p, r}, which gives the forest G[F ] of G at the bottom left, with four connected components, the vertices of F becoming colored in black. Vertex b does not belong to V F since its neighbors a and g belong to the same connected component of G  F . Observe also that {c, e, i, k, m, o, q} is the only stable set of V F with 6 vertices, but it contains vertices i and o, and the addition of these two vertices to F creates the cycle (i, j, o, n). The next Property indicates which stable sets S in V F ensure that G[F ∪ S] is a forest of G. Property 2.1 Let F be the vertex set of an induced forest of a graph G, let S be a stable set in V F , and let F since the vertices in S ′′ have no neighbor in S ′ . Hence, no vertex in S ′′ has more than one neighbor in F ′ and we have observed that this implies In the example of Figure 1 such that G[F ∪ S ′ ] is a forest of G. We can then easily determine a maximum stable set S ′′ among the vertices of V ≤1 F that are not adjacent to any vertex of S ′ , and this will give a stable set S = S ′ ∪ S ′′ so that G[F ∪ S] is a forest of G.
We will restict our attention to stable sets S with S ⊆ X or S ⊆ Y . So, let G = (X, Y, E) be a bipartite graph. We first show how to determine a stable set is a forest of G. As mentioned above, we assume that G[F ] has r connected components with vertex sets C 1 , C 2 , . . . , C r . We set A = {1, 2, . . . , r} and construct a bipartite graph H X (F ) with bipartition (V X , A) of its vertex set and with edge set Figure 1, assuming that a ∈ X, C 1 = {a, f, g, h}, C 2 = {j}, C 3 = {n, r}, and C 4 = {p}, we have H X (F ) equal to the graph at the top left of Figure 2. The removal of i from V X deletes all cycles in H X (F ). Hence, by setting S X = {m, o}, we can conclude that A ∪ S X induces a forest in H X (F ), which means that G[F ∪ S X ] is a forest of G, as shown at the bottom left of Figure 2.  Finding a stable set S X ⊆ V X of maximum cardinality so that S X ∪ A induces a forest in H X (F ) is a difficult problem since it is equivalent to determining the smallest decycling set D of H X (F ) with the additional constraint that D ⊆ V X . Since the tabu search described in the next section will perform this task many times, we have decided to use a greedy algorithm that works as follows. We start by setting S X equal to the empty set, and then iteratively increase S X ensuring that S X ∪ A induces a forest in H X (F ). Let W be the set of vertices v of V X so that S X ∪ A ∪ {v} induces a forest in H X (F ). At each step of the iterative process, we choose a vertex v ∈ W with minimum degree d H X (F ) (v), add it to S X and update W . Hence, W is initially equal to V X , and the algorithm stops when W is empty. Algorithm GreedyStable describes the general steps of this algorithm. Its input is a bipartite graph H = (X, Y, E) and its output is a subset S ⊆ X so that

5:
Remove v from W as well as all vertices u that belong to a cycle of H[S ∪ Y ∪ {u}]. The same process can be repeated with Y instead of X. More precisely, we can construct the graph is a stable set of G = (X, Y, E) since all vertices of this set belong to the same part X of the bipartition (X, Y ) of the vertex set of G. We are now ready to explain how we extend an induced forest G[F ] of a bipartite graph G = (X, Y, E) by adding a stable set S so that G[F ∪ S] is also a forest of G. We first construct H X (F ) and H Y (F ) and then apply Algorithm GreedyStable to both bipartite graphs to obtain sets S X and S Y such that G[F ∪S X ] and G[F ∪S Y ] are forests of G. We then compare n Hence n X = 2 + 3 = 5 and n Y = 2 + 1 = 3. We therefore add {c, e, k, m, n} to F to obtain the forest drawn at the bottom right of Figure 1. Algorithm ForestExtension describes the general steps of this procedure.
Several remarks are worth making at this stage. Algorithm ForestExtension determines a stable set S with S ⊆ X or S ⊆ Y while a larger stable set S ′ could exist in X ∪ Y so that G[F ∪ S ′ ] is a forest of G. Also, we only look for forest extensions G[F ∪ S] of G[F ] obtained by adding a stable set S, while larger forests G[F ∪ W ] of G might exist for non-stable sets W . For the example of Figure 1 a forest with 14 vertices is depicted at the top right. It is obtained by adding the non-stable set {c, d, e, k, l, q} to F . But finding the largest set W so that G[F ∪ W ] is a forest of G is an NP-hard problem since it is equivalent to determining φ(G) when F = ∅.

Algorithm ForestExtension
Input : a bipartite graph G = (X, Y, E) and a vertex set Note that if we look for stable sets S with both S ∩ X and S ∩ Y possibly not empty and with The variations of Algorithm ForestExtension mentioned above necessitate the solution of maximum stable set problems in bipartite graphs. Even if this task can be done in polynomial time, it is too time consuming for the tabu search procedure described in the next subsection, where Algorithm ForestExtension has to be applied many times.

A tabu search
The proposed heuristic for producing a large induced forest in a given bipartite graph G is based on the tabu search metaheuristic, which is one of the most frequently used in combinatorial optimization [15]. Tabu search is a local search technique that visits a solution space S by moving step by step from a current solution s ∈ S to a neighbor solution s ′ ∈ N (s), where N (s) is a subset of S called the neighborhood of s. A tabu list forbids some moves which would bring the search back to a recently visited solution. The best move that does not belong to the tabu list is chosen at each iteration. Tabu search was introduced by Glover [14]. A description of the method and its concepts can be found in [15].
The proposed adaptation of the tabu search metaheuristic to our problem can be roughly described as follows. We first choose a vertex set F so that G[F ] is a forest of G = (X, Y, E). Such a set F can be obtained, for example, by means of the following greedy algorithm: start with an empty set F , consider all vertices v of G in non-decreasing degree order, and sequentially add them to F when G[F ∪ {v}] is a forest of G. But this initial set F can be chosen in many other different ways. For example, it can be the vertex set of the best-known induced forest of G that we try to improve. We can also impose F ∩ X = X so that F contains all the vertices of X or, on the contrary, we can impose F ⊆ Y so that F does not contains any vertex of X. There are actually no restrictions on F except that G[F ] must be a forest of G.
As mentioned earlier, the proposed tabu search explores the space S that contains all the induced forests of G which have fixed numbers of vertices in X and in Y , and for each considered forest, we will try to extend it by adding a stable set of G. Once an initial induced forest F is chosen, we set k X = |F ∩ X|, k Y = |F ∩ Y | and therefore define the solution space S as the set of all vertex sets F ′ such that The neighborhood N (F ) of F ∈ S contains all vertex sets F ′ ∈ S that can be obtained from F by replacing a vertex u ∈ F ∩ X by a vertex v ∈ X \ F , or by replacing a vertex . The value f (F ) of a set F ∈ S is measured by using Algorithm ForestExtension that produces a stable set S such that G[F ∪ S] is a forest of G. More precisely, we fix f (F ) equal to |F | + |S|, where S is the output of Algorithm ForestExtension. Note that F = F ′ ⊕ (v, u), and there is therefore a risk that the algorithm removes v and adds u in the next iterations to return to F , which could cause the algorithm to cycle. To avoid this, when moving from a set F to F ⊕ (u, v), we put u and v in a tabu list, which means that we forbid the visit of sets F ′ ∈ S with u ∈ F ′ or v / ∈ F ′ . These restrictions are only effective for a limited number of iterations. It is customary to keep them active for a number of iterations proportional to the square root of the number of other possible choices. Let Z ∈ {X, Y } be so that u and v both belong to Z. Since |Z| − k Z vertices (including u) of Z do not belong to F ′ while k Z of them are part of it (including v), we keep u and v in the tabu list for |Z| − k Z and √ k Z iterations, respectively. The stopping criterion is a time limit. Algorithm LargeForest describes this tabu search, where G[F * ] is the best found forest of G, BestValue is the largest value f (F ′ ) of a non-tabu neighbor F ′ ∈ N (F ), and ListBest is the set of non-tabu neighbors F ′ of F with f (F ′ ) =BestValue. At each iteration, the algorithm moves from a set F to a neighbor F ′ chosen at random in ListBest. Note that if a neighbor F ′ of F is found at step 10 with value f (F ′ ) > |F * |, then the possible tabu status of the move from F to F ′ is cancelled (i.e., the move from F to F ′ = F ⊕ (u, v) is accepted, even if u or v belong to the tabu list). Also, when f (F ′ ) > |F * |, we stop exploring the neighborhood N (F ) and start a new iteration from F ′ .
Algorithm LargeForest can be considered as an upper bounding procedure for the computation of the decycling number of arbitrary bipartite graphs. Indeed, its output F * indicates that G[F * ] is a forest of G, which is equivalent to say that V \ F * is a decycling set of G. Hence, |V | − |F * | is an upper bound on the decycling number ϕ(G) of G. In the following, this upper bound will be denoted U B(G).

Computational experiments.
There are very few hard instances in the literature for the computation of the decycling number of bipartite graphs. We found several exceptions, where the gap between the best-known lower and upper bounds is not zero, namely, star graphs, bubble sort graphs, Fibonacci cubes, and hypercubes. These families of bipartite graphs are our test sets for the next subsections. We use a 3 GHz Intel Xeon X5675 machine with 8 GB of RAM.

Star graphs
The star graph S n has a vertex for every permutation v = v 1 , v 2 , . . . , v n of the integers 1, 2 . . . , n, and two vertices v = v 1 , v 2 , . . . , v n and u = u 1 , u 2 , . . . , u n are adjacent if there is i ∈ {2, . . . , n} Algorithm LargeForest Input : a bipartite graph G = (X, Y, E) Output : a set F * such that G[F * ] is a forest of G.
1: Choose a set F such that G[F ] is a forest of G 2: Set k X ← |F ∩ X|, k Y ← |F ∩ Y |, F * ← F and T abuList ← ∅. 3: while the time limit is not reached do

5:
for all u, v with u ∈ F ∩ X and v ∈ X \ F or u ∈ F ∩ Y and v ∈ Y \ F do 6: Apply Algorithm ForestExtension to determine a stable set S such that G[F ′ ∪ S] is a forest of G.  Set F * ← F ′ ∪ S, F ← F ′ and go to step 4.   Choose a set F ′ ∈ ListBest an let u, v be such that F ′ = F ⊕ (u, v).

24:
if u and v both belong to X then set Z ← X else set Z ← Y end if 25: Keep u and v in T abuList for |Z| − k Z and √ k Z iterations, respectively.

26:
Set F ← F ′ . 27: end while such that v 1 = u i , v i = u 1 , and v j = u j for all j ̸ = 1, i. For illustration, S 3 and S 4 are depicted in Figure 3. Clearly S n is bipartite and has n! vertices and n!(n−1) 2 edges. Star graphs have many nice topological properties that provide attractive interconnection schemes for massively parallel systems [1,2]. Their decycling number is studied in [29] where it is proved that ϕ(S 1 ) = ϕ(S 2 ) = 0, ϕ(S 3 ) = 1, ϕ(S 4 ) = 7, and Algorithm LargeForest starts with the generation of a vertex set F such that G[F ] is a forest of G, and then sets k X = |F ∩ X| and k Y = |F ∩ Y |, which means that every vertex set in the solution space S of the tabu search has k X vertices in X and k Y vertices in Y . As explained in Section 2.2, this initial set F can be obtained in various ways.
Our initial choice was to produce the initial forest with the help of a greedy algorithm. For example, for S 7 , we got a forest of order 2, 258. Much larger forests are however easy to obtain by imposing that F must contain one side, say Y , of the bipartition (X, Y ) of the vertex set of S n . This can be done as follows : use Algorithm GreedyStable on S n = (X, Y, E) to obtain a stable set S ⊆ X so that S n [S ∪ Y ] is a forest of S n , and then set F = S ∪ Y . For S 7 , this process has given a forest of order 2, 931, and we have therefore fixed k X = 2931 − 1 2 7! = 411 and k Y = 1 2 7! = 2520. For S 5 and S 6 , the same initialization process resulted in forests of order 76 and 436, respectively. The results produced by Algorithm LargeForest with these initial forests are reported in Table  1. For every n, we indicate the order |V | and the size |E| of S n , as well as the above-mentioned lower and upper bounds L(S n ) and U (S n ). For Algorithm LargeForest, we indicate the values of k X and k Y , and report the number of iterations (column 'Iter') and the CPU time (column 'time') needed to obtain the upper bound U B(S n ) on ϕ(S n ). For S 7 , we also indicate the time required to reach certain intermediate values. The complete evolution of the U B(S 7 ) bound is shown in Figure 4.
Bounds from [29] n |V | |E| L(S n ) U (S n )  We observe that for n = 5 and 6, our upper bound U B(S n ) equals the lower bound L(S n ), which means that we have proved that ϕ(S 5 ) = 41 and ϕ(S 6 ) = 271, and this proof is obtained in less than a second for S 5 , and in 3 seconds for S 6 . For S 7 , the upper bound U (S 7 ) is reached in 32 seconds. The algorithm was stopped after ten days of computation, and our upper bound U B(S 7 ) = 2018 is 65 units lower than that of Wang et al. [29], which represents a decrease of 98% of the gap. A smaller upper bound may have been reached if more time had been allocated. Note that ϕ(S n ) = L(S n )) for n ≤ 6 which could mean that this is also true for larger values of n.
We then tried other values for k X and k Y . As explained in Section 2.2, knowledge of a large induced forest can be used to generate an initial set F at step 1 of Algorithm LargeForest. Such a large forest is known for S n . Indeed, to demonstrate the validity of their upper bound U (S n ) on ϕ(S n ), Wang et al. [29] have shown how to construct a decycling set D of S n = (X, Y, E) with |D ∩ X| = U (S n ) and D ∩ Y = ∅. This means that (X \ D) ∪ Y induces a forest of order n! − U (S n ) in S n . Hence, by setting F = X \ D at step 1 of Algorithm LargeForest and running ForestExtension with S n and F as input, we immediately obtain a forest S n [F ∪ Y ] of S n with n! − U (S n ) vertices. In order to generate larger forests, we set F = (X \ D) ∪ R, where R contains r vertices chosen at random in D, with r ∈ {1, . . . , U (S n )}. Hence, k X = 1 2 n! − U (S n ) + r, k Y = 0, and if Algorithm LargeForest succeeds in determining a forest S n [F * ] of S n with Y ⊆ F * , this means that we have found a forest of order ( 1 2 n! − U (S n ) + r) + 1 2 n! = n! − (U (S n ) − r), thus decreasing by r units the best-known upper bound on ϕ(S n ). We tested several values for r and the best results for S 7 were obtained with r = 12, which gives k X = 7! − 2083 + 12 = 449 and k Y = 0. With this setting, Algorithm LargeForest has reached the upper bound U (S 7 ) = 2, 083 of Wang et al. [29] in 20 iterations that required one hour and 42 minutes of calculation. We were only able to improve it by 8 units in 2 days of calculation, thus producing a bound which is 57 units higher than that obtained with the other setting. These tests are therefore not reported in Table 1.
An analysis of the computing times shows that the first iterations take less than a second (because, at step 11 of LargeForest, we stop exploring N (F ) when a neighbor F ′ of F is found with value f (F ′ ) > |F * |), while subsequent iterations (which require O(k X (|X|−k X )+k Y (|Y |−k Y )) calls to Algorithm ForestExtension) can take a few seconds. Computing times are shorter with k X = 411 and k Y = 2520 than with k X = 449 and k Y = 0, the reason being that with the first setting, Algorithm ForestExtension has to determine stable sets S having only a few tens of vertices, while with the second setting, S typically contains about 2500 vertices.
Still dealing with S 7 , we have tried to initialize F by choosing 449 vertices at random in Y , without taking into account the decycling set described in [29]. This also gives k X = 449 and k Y = 0. With this other start, Algorithm LargeForest has produced an initial forest of 2, 662 vertices and therefore a decycling set of 2, 378 vertices. It would have taken days of computation to decrease this initial upper bound by 360 units (to get an upper bound equal to 2378 − 360 = 2018). These tests are therefore not reported in Table 1.

Bubble sort graphs
The bubble sort graph B n has the same vertex set as the star graph S n , but not the same edge set. More precisely, there is a vertex in B n for every permutation v = v 1 , v 2 , . . . , v n of the integers 1, 2 . . . , n, and two vertices v = v 1 , v 2 , . . . , v n and u = u 1 , u 2 , . . . , u n are adjacent if there is i ∈ {1, 2, . . . , n − 1} such that v i = u i+1 , v i+1 = u i , and v j = u j for all j ̸ = i, i + 1. For illustration, B 3 and B 4 are depicted in Figure 5. Clearly B n is bipartite and has n! vertices and n!(n−1) 2 edges. Bubble sort graphs were first introduced by Akers and Krishnamurthy [2] as a new type of interconnection network. As mentioned in [30], bubble sort graphs are attractive because of their simple, symmetric and recursive structure. The decycling number of these graphs is studied in [30] and the authors have proved that ϕ(B 1 ) = ϕ(B 2 ) = 0, ϕ(B 3 ) = 1, ϕ(B 4 ) = 7, and Algorithm LargeForest is applied to B 5 , B 6 and B 7 , with the initialization process that produced the best results for star graphs. More precisely, Algorithm GreedyStable is run with B n = (X, Y, E) as input to obtain a stable set S ⊆ X so that B n [S ∪ Y ] is a forest of B n , and we then set F = S ∪ Y . For B 7 , this process has given a forest of order 2, 932, and we have therefore fixed k X = 2932 − 1 2 7! = 412 and k Y = 1 2 7! = 2520. For B 5 and B 6 , the same initialization process resulted in forests of order 76 and 437, respectively. The results produced by Algorithm LargeForest with these initial forests are reported in Table 2, with the same column labels as in Table 1.
Bounds from [30] n  We observe that for n = 5 and 6, our upper bound U B(B n ) equals the lower bound L(B n ), which means that we have proved that ϕ(B 5 ) = 41 and ϕ(B 6 ) = 271. For B 7 , the process was stopped after one day of computation, and we could improve the best-known upper bound by 274 units, which represents a decrease of 94% of the gap. A smaller upper bound may have been reached if more time had been allocated. Note that ϕ(B n ) = L(B n )) for n ≤ 6 which could mean that this is also true for larger values of n.

Fibonacci cubes
The Fibonacci numbers form a sequence of positive integers {f n } ∞ n=0 such that each number f n is the sum of the two preceding ones, starting from f 0 = 1 and f 1 = 2. All non-negative integers i such that i ≤ f n − 1 can be uniquely represented as a sum of distinct non-consecutive Fibonacci numbers in the form i = n−1 j=0 b j f j , where b j is either 0 or 1, for 0 ≤ j ≤ n − 1, with the condition b j b j+1 = 0 for 0 ≤ j < n − 1 [32]. The sequence (b n−1 , . . . , b 1 , b 0 ) is called the order-n Fibonacci code of i, and uniquely determines i. For example, i = 19 ≤ f 6 − 1 = 20 has order-6 Fibonacci code (1, 0, 1, 0, 0, 1). The Fibonacci cube of order n, denoted Γ n , has vertex set {0, 1, . . . , f n − 1}, and two vertices i and j are adjacent if and only if their order-n Fibonacci codes differ in exactly one bit. The Fibonacci cubes for n ≤ 4 are depicted in Figure 6.
Fibonacci cubes were first introduced by Hsu [16], and properties are described in [11,21,24,31]. The decycling number of Γ n is known for n ≤ 9. For larger n, lower and upper bounds on ϕ(Γ n ) were obtained using various techniques. The best-known bounds L(Γ n ) and U (Γ n ) appear in [11] and are reported in Table 3 for n ≤ 14.
Let (X, Y ) be the bipartition of the vertex set of Γ n , and assume without loss of generality that |X| ≤ |Y |. It is easy to check that |X| = |Y | or |Y | − 1.
Algorithm LargeForest was first tested with the initialization process of the previous sections, where the forests generated at step 1 contain all vertices of Y (i.e., k Y = |Y |) and some of X. The results are reported in Table 3. We observe that the best-known upper bound U (Γ n ) is easily   reached for all n, and we have improved it by one unit for n = 12, by 5 units for n = 13, and by 13 units for n = 14.
As done for star graphs, we have tested another initialization process by fixing k X = |X| − U (Γ n ) + r and k Y = 0 with r > 0, but without taking into account the structure of the known forest of order n! − U (Γ n ). In other words, our initial set F contains k X vertices chosen at random in X. If Algorithm LargeForest succeeds in determining a forest Γ n [F * ] of Γ n with Y ⊆ F * , this means that we have found a forest of order k X + |Y | = (|X| − U (Γ n ) + r) + |Y | = f n − (U (Γ n ) − r), thus decreasing by r units the best-known upper bound on ϕ(Γ n ). We can then stop the algorithm (since it cannot produce a forest with more that k X +max{|X|, |Y |} = k X +|Y | vertices) and rerun it with a larger value of r. The results produced with this setting are reported in Table 3 for some values of r. We observe that we reach the same bounds as with the previous setting, but in more time. As already indicated in Section 3.1, this can be explained by the fact that each iteration takes more time with k Y = 0 than with k Y = |Y | since the stable sets S added to the forests F are larger with k Y = 0.
Algorithm CliqueSearch was tested on Q n with 9 ≤ n ≤ 13. The results are reported in Table  4, with the same column labels as in the previous tables. The best-known lower and upper bounds L(Q n ) and U (Q n ) for Q n are taken from [25]. The upper bound U (Q n ) is based on the theory of error-correcting codes, where U (Q n ) = 2 n−1 − 2 n−r−1 with n = 2 r − x and 0 ≤ x < 2 r−1 .
We also report the upper bounds published one year earlier in [5] to demonstrate that Pike's work [25] has considerably reduced the value of these bounds.

Algorithm CliqueSearch
Input : graph H n . Output : a clique K in H n so that G[K ∪ Y ] is a forest of Q n .
1: Generate a maximal clique F in H n and set K ← F and k = |F | + 1. Set BestValue← 0 and ListBest← ∅.

5:
for all u ∈ F and v ∈ X \ F do 6: Set F * ← F ′ and go to step 22.   Choose a set F ′ ∈ListBest an let u, v be such that F ′ = F ⊕ (u, v).

21:
Keep u and v in T abuList for |X| − k and √ k iterations, respectively.

25:
Choose a vertex u ∈ X \ F and set F ← F ∪ {u} and F * ← F .

26:
end if 27: end while We observe that Algorithm CliqueSearch reaches the best-known upper bounds in at most 1 second. Note that Q 13 has 8, 192 vertices and 53, 248 edges, which means that hours or days of computations would probably have been necessary to reach the same bounds with the original version of Algorithm LargeForest.

Concluding remarks
We have described a tabu search procedure that determines decycling sets of small size in arbitrary bipartite graphs G. The algorithm explores the set of induced forest of G of fixed order and tries to extend these forests to larger ones by adding stable sets. We have shown that the procedure is effective on challenging families of bipartite graphs. Indeed, we have decreased most of the bestknown upper bounds on ϕ(G), thus narrowing the gap to the best-known lower bounds. On four occasions we even managed to close this gap, which allows us to state that ϕ(B 5 ) = ϕ(S 5 ) = 41 and ϕ(B 6 ) = ϕ(S 6 ) = 271. The updated bounds for the tested graphs with a strictly positive gap are as follows, the old upper bounds being shown in parentheses: Most of the largest forests produced by our algorithm contain all vertices of one part of the bipartition (X, Y ) of the vertex set of G. Assuming |X| ≤ |Y |, this has led us to fix k Y = 0 or k Y = |Y |, which helps speed up the algorithm since the moves from a solution F to a solution F ′ = F ⊕(u, v) are restricted to pairs u, v of vertices that both belong to X. Such forests correspond to decycling sets fully contained in X. Notice however that it is easy to construct bipartite graphs G = (X, Y, E) with no decycling set of minimum size fully contained in X or Y . In the example of Figure 8, the only optimal decycling set contains two adjacent vertices x and y which therefore belong to different parts of the bipartition of the vertex set. Algorithm LargeForest is flexible enough to allow the discovery of any induced forest of G (and therefore of any decycling set of G). Indeed, a forest G[F * ] of G can be generated with k X = |F * ∩ X| and k Y ≤ |F * ∩ Y | : Algorithm LargeForest has to determine a set F so that F ∩ X = F * ∩ X, F ∩ Y ⊆ F * ∩ Y and G[F ] is a forest of G, and Algorithm GreedyStable can then extend F to F * by adding the stable set F * \ F ⊆ Y .
We have observed in Section 3.4 that knowledge of the structure of the considered bipartite graph can help speed up the proposed upper bounding procedure. For example, several authors have realized that optimal forests in Q n are unions of stars. With this assumption, we have been able to match the best-known upper bounds for ϕ(Q n ) (n ≤ 13) in at most one second, while these graphs have up to 8,192 vertices. Hence, an analysis of the structure of the best-known induced forests of a bipartite graph can facilitate the generation of large induced forests.
x y Figure 8: A bipartite graph with adjacent vertices in all optimal decycling sets.
Every iteration of Algorithm LargeForest requires O(k X (|X| − k X ) + k Y (|Y | − k Y )) calls to Algorithm ForestExtension. In order to speed up the algorithm, we can fix an upper limit k max on k X and k Y . If this limit has a too low value, it can prevent Algorithm LargeForest from generating an induced forest of G of maximum order. For example, if k max = 0, then the output F * of Algorithm LargeForest will be a stable set with max{|X|, |Y |} vertices. For the bubble sort graph B 7 , this would lead to an upper bound of 2, 520 on ϕ(B 7 ) while it is very easy to generate decycling sets of B 7 with less than 2, 100 vertices. If an optimal forest has x vertices in X and y vertices in Y , then k max should at least be equal to min{x, y}. In summary, small values for k max make it possible to speed up Algorithm LargeForest, but finding the smallest value of k max which makes it possible to generate an optimal induced forest is a real challenge.
We want to mention that we did not seek to optimize the code by using structures making it possible to efficiently manage the fusion of connected components when adding a vertex to a forest, or their splitting when removing a vertex. This would certainly reduce the computing times somewhat. The aim of this article was to demonstrate that the proposed algorithm makes it possible to generate large induced forests in bipartite graphs and thus obtain small decycling sets.
Note finally that the smallest decycling sets generated by our algorithm for star graphs, bubble sort graphs, and Fibonacci cubes are archived online at www.gerad.ca/~alainh/decycling.html.