Bandwidth and Distortion Revisited

Recently the NP-complete BANDWIDTH problem, together with a similar problem of embedding a graph into a real line with minimal distortion (called DISTORTION in this paper), attracted some attention from the side of exact (and therefore not polynomial) algorithms. Given a graph G with n vertices, an ordering is a bijective function π : V (G) → {1, 2, . . . , n}. Bandwidth of π is a maximal length of an edge, i.e., bw(π) = max uv∈E(G) |π(u)π(v)|. The BANDWIDTH problem, given a graph G and a positive integer b, asks if there exists an ordering of bandwidth at most b. Given a graph G, an embedding of G into a real line is a function π : G → R. For every pair of distinct vertices u, v ∈ V (G) we define a distortion of u and v by dist(u, v) = |π(u)π(v)|/d G (u, v), where d G denotes the distance in the graph G. A contraction and an expansion of π, denoted contr(π) and expan(π) respectively, are the minimal and maximal distortion over all pairs of distinct vertices in V (G). The distortion of π, denoted dist(π), equals to expan(π)/contr(π). The DISTORTION problem, given a graph G and a positive real number d, asks if there exists an embedding with distortion at most d. Note that the distortion of an embedding does not change if we change π afinitely, and we can rescale π by 1/contr(π) and obtain π with contraction exactly 1. Therefore, in this paper, we limit ourselves only to embeddings with contraction at least 1 and we optimize the expansion of the embedding, that is, we try to construct embeddings with contraction at least 1 and with expansion at most d. The first non-trivial exact algorithm for the BANDWIDTH problem was developed by Feige and Kilian in 2000 [6]. It works in polynomial space and O * (10 n ) time. Recently we improved the time bound to O * (5 n ) [4], O(4.83 n ) [3] and O * (20 n/2 ) [5]. However, the cost of the improvements was exponential space complexity: O * (2 n ), O * (4 n ), O * (20 n/2 ) respectively. In 2009 Fomin et al. [9] adopted some ideas from [4] to the DISTORTION problem and obtained a O(5 n+o(n) )-time and O * (2 n )-space algorithm. It is worth mentioning that the considered problems, although very similar form the exact computation point of view, differ from the point of parameterized computation. The BAND-WIDTH problem is hard for any level of the W hierarchy [2], whereas DISTORTION is fixed parameter tractable where parameterized by d [8]. However, the FPT algorithm for DISTORTION works in O(nd 4 (2d + 1) 2d ) time, which does not reach the O(c n ) complexity for d = Ω(n). In this paper we present a link between aforementioned results and develop O(9.363 n )-time and polynomial space algorithms for both BANDWIDTH and DISTORTION. First, we develop a O(4.383 n )-time and space algorithm for DISTORTION, using ideas both from O * (20 n/2 ) algorithm for BANDWIDTH 1 [5] and O(5 n+o(n) ) algorithm for DISTORTION [9]. Then, we use an approach somehow similar to these of Feige and Kilian [6] to reduce space to polynomial, at the cost of time complexity, obtaining the aforementioned algorithms. We are not aware of any exact polynomial-space algorithms that work in O(c n ) time for DISTORTION or are faster than Feige and Kilian's algorithm for BANDWIDTH. In Section 2 we gather results on partial bucket functions: tool that was used in all previous algorithms for DISTORTION and BANDWIDTH. In Section 3 we recall the O * (20 n/2 ) algorithm [5] and show how to transform it into O(9.363 n )-time and polynomial space algorithm for BANDWIDTH. Section 4 is devoted to DISTORTION: first, we merge ideas from [4] and [9] to obtain an O * (4.383 n )-time and space algorithm for DISTORTION. Then we apply the same trick as for BANDWIDTH to obtain an O(9.363 n )-time and polynomial space algorithm. In the following sections we assume that we are given a connected undirected graph G = (V, E) with n = |V |. Note that BANDWIDTH trivially decomposes into subproblems on connected components, whereas answer to DISTORTION is always negative for a disconnected graph. Proofs of results marked with ♣ are postponed to Appendix B. In this section we gather results on partial bucket functions, a tool used in algorithms for both BANDWIDTH and DISTORTION. Most ideas here are based on the O * (20 n/2 ) algorithm for BANDWIDTH [5]. We say that such a function f is a bucket extension of f . or state that such bucket extension does not exist. Proof. The case A = B = ∅ is trivial, so we may assume there exists some v 0 ∈ B. W.l.o.g. we may assume f ′ (v 0 ) = 0. Therefore any valid bucket extension should satisfy f (V ) ⊆ {-n, -n + 1, . . . , n}. We calculate for every v ∈ V \ A the value p(v) ⊆ {-n, -n + 1, . . . , n}, intuitively, the set of possible values for f (v), by the following algorithm. 6: until some p(v) is empty or we do not change any p(v) in the inner loop 7: return True iff all p(v) remain nonempty. To prove that Algorithm 2.1 correctly checks if there exists a valid bucket extension f note the following: 2. If the algorithm returns nonempty p(v) for every v ∈ V \ A, setting f (v) = min p(v) constructs a valid bucket extension of (A, f ). Moreover, since we start with Corollary 2.4. One can check in polynomial time whether a given pair (A, f ) is a partial bucket function. Moreover one can check whether (A ′ , f ′ ) is a successor of (A, f ) in polynomial time too. Proof. To check if (A, f ) is a partial bucket function we simply run the algorithm from Lemma 2.3 for B = A and f ′ = f . Conditions for being a successor of (A, f ) are trivial to check. Lemma 2.5. Let N ∈ Z + . Then there are at most Proof. Note that if (A, f ) is a partial bucket function in the graph G and f is a bucket extension, and G ′ is a graph created from G by removing an edge, then (A, f ) and f remain partial bucket function and its bucket extension in G ′ . Therefore we may assume that G is a tree, rooted at v r . There are 2N possibilities to choose the value of f (v r ) and whether v r ∈ A or v r / ∈ A. We now construct all interesting triples (A, f, f ) in a root-to-leaves order in the graph G. If we are at a node v with its parent w, then f (v) ∈ {f (w) -1, f (w), f (w) + 1}. However, if w ∈ A then we cannot both have f (v) = f (w) + 1 and v / ∈ A. Similarly, if w / ∈ A then we cannot both have f (v) = f (w) -1 and v ∈ A. Therefore we have 5 options to choose f (v) and whether v ∈ A or v / ∈ A. Finally, we obtain at most 2N • 5 n-1 triples (A, f, f ). Let (A, f ) be a partial bucket function. Then all bucket extensions of f can be generated with a polynomial delay, using polynomial space. The proof of the theorem below is an adjusted and improved proof of a bound of the number of states in the O * (20 n/2 ) algorithm for BANDWIDTH [5]. The proof can be found in Appendix A. Theorem 2.7. Let N ∈ Z + . There exists a constant c < 4.383 such that there are O(N • c n ) partial bucket functions (A, f ) such that there exists a bucket extension f satisfying f (V ) ⊆ {1, 2, . . . , N }. Moreover, all such partial bucket functions can be generated in O * (N • c n ) time using polynomial space. 3 Poly-space algorithm for BANDWIDTH In this section we describe an O(9.363 n )-time and polynomial-space algorithm solving BAND-WIDTH. As an input, the algorithm takes a graph G = (V, E) with |V | = n and an integer 1 ≤ b < n and decides, whether G has an ordering with bandwidth at most b. First, let us recall some important observations made in [4]. An ordering π is called a b-ordering if bw(π) ≤ b. Let Pos = {1, 2, . . . , n} be the set of possible positions and for every position i ∈ Pos we define the segment it belongs to by segment(i) = ⌈ i b+1 ⌉ and the color of it by color(i) = (i -1) mod (b + 1) + 1. By Seg = {1, 2, . . . , ⌈ n b+1 ⌉} we denote the set of possible segments, and by Col = {1, 2, . . . , b + 1} the set of possible colors. The pair (color(i), segment(i)) defines the position i uniquely. We order positions lexicographically by pairs (color(i), segment(i)), i.e., the color has higher order that the segment number, and call this order the color order of positions. By Pos i we denote the set of the first i positions in the color order. Given some (maybe partial) ordering π, and v ∈ V for which π(v) is defined, by color(v) and segment(v) we understand color(π(v)) and segment(π(v)) respectively. Let us recall the crucial observation made in [4]. First let us recall the O * (20 n/2 )-time and space algorithm from [5]. is a successor of the state (A k , f k ) with the vertex v k+1 . Let π be an ordering assigning v k to the k-th position in the color order. Then π is a b-ordering. The algorithm of [5] works as follows: we do a depth-first search from the state (∅, ∅) and seek for a state (V, •). At a state (A, f ) we generate in polynomial time all successors of this state and memoize visited states. Theorem 3.3 implies that we reach state (V, •) iff there exists a b-ordering. Moreover, Theorem 2.7 (with N = n) implies that we visit at most O(4.383 n ) states; generating all successors of a given state can be done in polynomial time due to Corollary 2.4, so the algorithm works in O(4.383 n ) time and space. Proof. First note that a set A i determines the function f i , since If m = 1, we need to check only if (B, g) is a successor of (A, f ), what can be done in polynomial time. Otherwise, let k = ⌊ a+b 2 ⌋ and guess A k : there are roughly 2 m choices. Set The algorithm clearly works in polynomial space; now let us estimate the time it consumes. At one step, it does some polynomial computation and invokes roughly 2 m+1 times itself recursively for ba ∼ m/2. Therefore it works in O * (4 m ) time. Let α = 0.5475. The algorithm works in the same fashion as in [5]: it seeks for a path of states ) is a successor of (A i , f i ) for 0 ≤ i < n. However, since we are limited to polynomial space, we cannot do a simple search. Instead, we guess middle states on the path, similarly as in Lemma 3.4. The algorithm works as follows: 1. Let k := ⌊αn⌋ and guess the state (A k , f k ). By Theorem 2.7 with N = n, we can enumerate all partial bucket functions in O(4.383 n ). We enumerate them and drop those that are not states or have the size of the domain different than k. 2. Using Lemma 3.4, check if there is a path of states from (∅, ∅) to (A k , f k ). This phase works in time 4 αn . In total, for all (A k , f k ), this phase works in time O(4.383 n •4 αn ) = O(9.363 n ). 3. Guess the state (V, f n ): f n needs to be a bucket extension of the partial bucket function (A k , f k ). By Lemma 2.6, bucket extensions can be enumerated with polynomial delay; we simply drop those that are not states. By Lemma 2.5 with N = n, there will be at most Return true, if for any (A k , f k ) and (V, f n ) both applications of Lemma 3.4 return success. Theorem 3.3 ensures that the algorithm is correct. In memory we keep only states (A k , f k ), (V, f n ), recursion stack generated by the algorithm from Lemma 3.4 and state of generators of states (A k , f k ) and (V, f n ), so the algorithm works in polynomial space. Comments above prove that it consumes at most O(9.363 n ) time. We consider algorithms that, given a connected graph G with n vertices, and positive real number d decides if G can be embedded into a line with distortion at most d. First, let us recall the basis of the approach of Fomin et al. [9]. Recall that d G (u, v) denotes the distance between vertices u and v in the graph G. Therefore, we only consider pushing embeddings and hence assume that d is a positive integer. Note that a pushing embedding of a connected graph of at least 2 vertices has contraction exactly Therefore distortion equals expansion. As any connected graph with n vertices can be embedded into a line with distortion at most 2n -1 [1], this decisive approach suffices to find the minimal distortion of G. We may assume that π(V ) ⊆ {1, 2, . . . , n(d + 1)}. Now, let us introduce the concept of segments, adjusted for the DISTORTION problem. Here the set of available positions is Pos = {1, 2, . . . , n(d + 1)} and a segment of a position i is segment(i) = ⌈ i d+1 ⌉, i.e., a j-th segment is an integer interval of the form {(j -1)(d + 1) + 1, (j -1)(d + 1) + 2, . . . , j(d + 1)}. The color of a position is color(i) = (i -1)mod(d + 1) + 1. By Seg = {1, 2, . . . , n} we denote the set of possible segments and by Col = {1, 2, . . . , d + 1} the set of possible colors. The pair (color(i), segment(i)) defines the position i uniquely. We order the positions lexicographically by pairs (color(i), segment(i)) and call this order color order of positions. By Pos i we denote the set of the first i positions in the color order and by Seg i we denote the set of positions in the i-th segment. Given some, maybe partial, embedding π, by color(v) and segment(v) we denote color(π(v)) and segment(π(v)) respectively. Similarly as in the case of BANDWIDTH, the following equivalence holds (cf. Lemma 3.1). Let π be a pushing embedding. Then π has distortion at most d iff for ev- Similarly as in [9], we solve the following extended case of DISTORTION as a subproblem. As an input to the subproblem, we are given an induced subgraph G[X] of G, an integer r (called the number of segments), a subset Z ⊆ X and a function π : Z → Seg 0 ∪ Seg r+1 . Given this input, we ask, if there exists a pushing embedding π : X → {-d, -d + 1, . . . , (r + 1)(d + 1)} with distortion at most d such that π| Z = π, π(X \ Z) ⊆ {1, 2, . . . , r(d + 1)}. Moreover, we demand that π does not leave any empty segment, i.e, for every Let n = |X \ Z|. The algorithm for Theorem 4.4 goes as follows. First, for each segment 1 ≤ i ≤ r we guess the vertex v i and position 1 ≤ p i ≤ r(d + 1) such that Seg(p i ) = i. There are roughly O(n O(r) ) possible guesses (if r > n the answer is immediately negative). We seek for embeddings π such that for every 1 ≤ i ≤ r position π(v i ) = p i , and there is no vertex assigned to any position in the segment i with color earlier than color(p i ), i.e., v i is the first vertex in the segment i. If there exists z ∈ Z such that π(z) ≤ 0, then we require that v 1 is pushed by such z that π(z) is the largest nonpositive possible. Along the lines of the algorithm for BANDWIDTH [5] and algorithm for DISTORTION by Fomin et al. [9], we define state and a state successor as follows: Definition 4.5. A state is a triple (p, (A, f ), (H, h)) such that: Definition 4.7. We say that a state (r(d + 1), (V, f ), (H, h)) is a final state iff for each segment The following equivalence holds: Lemma 4.8. Let π be a pushing embedding and a solution to the extended DISTORTION problem with distortion at most d. Assume that π(v i ) = p i and this is the first vertex in the segment i for every segment 1 ≤ i ≤ r, i.e., the initial guesses are correct with respect to the solution π. For each 1 ≤ p ≤ r(d + 1) we define (A p , f p ) and (H p , h p ) as follows: 1. A p = π -1 (Pos p ) and f p = segment| Ap , 2. for each segment 1 ≤ i ≤ r we take w i as the vertex in π -1 (Pos p ∩ Seg i ) with the greatest color of position and take Then S p = (p, (A p , f p ), (H p , h p ) is a state and S p+1 = (p + 1, (A p+1 , f p+1 ), (H p+1 , h p+1 )) is its successor if p < r(d + 1). Moreover, S r(d+1) is a final state. Proof. First note that, similarly as in the case of BANDWIDTH, (A p , f p ) is a partial bucket function and (A p+1 , f p+1 ) is a successor of (A p , f p ). Indeed, the conditions for a partial bucket function and its successor are implied by Lemma 4.3. The check that (H p , h p ) satisfies the conditions for being a state is straightforward. Let us now look at the conditions for the successor. The only nontrivial part is that if in H p the vertex w is replaced by v in H p+1 , then d G (v, w) = h p+1 (v)h p (w). However, this is implied by the fact that π is a pushing embedding. To see that S r(d+1) is a final state recall that π leaves no segment Seg i , 1 ≤ i ≤ r, nonempty and it is a pushing embedding. Lemma 4.9. Assume that we have a sequence of states (S p ) r(d+1) p=0 , S p = (p, (A p , f p ), (H p , h p )) such that S p+1 is a successor of S p for 0 ≤ p < r(d + 1) and S r(d+1) is a final state. Let π = r(d+1) p=0 h p . Then π is a solution to the extended DISTORTION problem with distortion at most d. Moreover, π(v i ) = p i for all 1 ≤ i ≤ r. Proof. Note that the conditions for the final state imply that π leaves every segment from 1 to r nonempty. Moreover, the conditions for (H p , h p ) imply that π(v i ) = p i and v i is the first vertex assigned in segment i. First we check if π is a pushing embedding. Let v and w be two vertices such that π(v) < π(w) and there is no u with π(v) < π(u) < π(w). If segment(v) = segment(w), then π(w)π(v) = d G (v, w) is ensured by the state successor definition at step, where S p+1 is a successor of the state S p with the vertex w. Otherwise, if segment(v) + 1 = segment(w), then w = v segment(v) or w is the first vertex of Z in segment r + 1 and the fact that v pushes w is implied by the condition of the final state. The possibility that segment(v) + 1 < segment(w) is forbidden since in the final state H r(d+1) ∩ Seg i = ∅ for 1 ≤ i ≤ r. Now we check if for each edge uv, |π(u)π(v)| ≤ d. Assume not, let π(u) + d < π(v) and let S k be a successor of the state S k-1 with the vertex v. By the conditions for a partial bucket function However, by the conditions for a partial bucket function successor, color(u) > color(v), a contradiction, since consecutive positions of the same color are in distance d + 1. Let us now limit the number of states. There are at most O * (4.383 n) partial bucket functions. Integer p = O(rd) and h p keeps position of at most one vertex in each segment, so there are O(n O(r) ) possible pairs (H p , h p ). Therefore, in total, we have O(4.383 nn O(r) ) states. Note that there at most n + 1 successors of a given state, since choosing A 2 \ A 1 defines the successor uniquely. Note that, as checking if a pair (A, f ) is a partial bucket function can be done in polynomial time, checking if a given triple is a state or checking if one state is a successor of the other can be done in polynomial time too. To obtain the O(4.383 nn O(r) )-time and space algorithm, we simply seek a path of states as in Lemma 4.9, memoizing visited states. To limit the algorithm to the polynomial space, we do the same trick as in the O(9.363 n ) algorithm for BANDWIDTH. Lemma 4.10. Assume that we have states S p = (p, (A p , f p ), (H p , h p )) and S q = (q, (A q , f q ), (H q , h q )) such that p < q, A p ⊆ A q and f p = f q | Ap . Let m = |A q \ A q |. Then one can check if there exists a sequence of states S i = (i, (A i , f i ), (H i , h i )) for i = p, p + 1, . . . , q such that the state S i+1 is a successor of the state numbered S i in time O(4 m n O(r log m) ). Proof. First, let us consider the case when m = 1. We guess index k, p < k ≤ q, such that A k = A q and f k = f q , but A k-1 = A p and f k-1 = f p . Note that then all states S i for p ≤ i ≤ q are defined uniquely: h i = h p for i < k and h i = h q for i ≥ k. We need only to check if all consecutive pairs of states are successors. Let now assume m > 1 and let s = |A p |+⌊m/2⌋. Let us guess the state S k such that |A k | = s. We need A p ⊆ A k ⊆ A q and f k = f q | A k , so we have only roughly 2 m possibilities for (A k , f k ) and O(dr) = O(nn) possibilities for the index k. As always, there are n O(r) possible guesses for (H k , h k ). We recursively check if there is a sequence of states from S p to S k and from S k to S q . Since at each step we divide m by 2, finally we obtain an O(4 m n O(r log m) ) time bound. Again we set α := 0.5475. with N = n, we can enumerate all partial bucket extensions in O(4.383 n). We enumerate all partial bucket functions, guess p and (H k , h k ) and drop those combinations that are not states. Note that there are O(n O(r) ) possible guesses for (H k , h k ) and dr ≤ n 2 guesses for p. 2. Using Lemma 4.10, check if there is a path of states from (0, (∅, ∅), (∅, ∅)) to S k . This phase works in time 4 αn n O(r log n) . In total, for all (A k , f k ), this phase works in time O * (4.383 n • 4 αn n O(r log n) ) = O(9.363 nn O(r log n) ). 3. Guess the final state S r(d+1) = (r(d + 1), (V, f r(d+1) ), (H r(d+1) , h r(d+1) )): f r(d+1) needs to be a bucket extension of the partial bucket function (A k , f k ). By Lemma 2.6, bucket extensions can be enumerated with polynomial delay. We guess h r(d+1) and simply drop those guesses that do not form states. By Lemma 2.5 with N = r, there will be at most O * (5 n) pairs of states (A k , f k ) and (V, f r(d+1) ). We have n O(r) possibilities for h r(d+1) . 4. Using Lemma 4.10, check if there is a path from the state S k to S r(d+1) . This phase works in time 4 (1-α)n n O(r log n) . In total, for all S k and S r(d+1) this phase works in time Proof. We almost repeat the argument from [9]. First, we may guess the number of nonempty segments needed to embed G into a line with a pushing embedding π with distortion at most d. Denote this number by r, i.e., r = ⌈max{π(v) : v ∈ V (G)}/(d + 1)⌉. Note that the original DISTORTION problem can be represented as an extended case with H = G and Z = π = ∅ and with guessed r. If r < n/ log 3 (n), the thesis is straightforward by applying Theorem 4.4. Therefore, let us assume r ≥ n/ log 3 (n). As every segment from 1 to r contains at least one vertex in a required pushing embedding π, by simple counting argument, there needs to be a segment r/4 ≤ k ≤ 3r/4 such that there are at most 4n/r ≤ 4 log 3 (n) vertices assigned to segments k and k + 1 in total by π. We guess: segment number k, vertices assigned to segments k and k + 1 and values of π for these vertices. We discard any guess that already makes some edge between guessed vertices longer than d. As d, r = O(n), we have n O(log 3 n) possible guesses. Let Y be the set of vertices assigned to segments k and k + 1 and look at any connected component C of G[V \Y ]. Note that if C has neighbours in both segment k and k+1, the answer is immediately negative. Moreover, as G was connected, C has a neighbour in segment k or k+1. Therefore we know, whether vertices from C should be assigned to segments 1, 2, . . . , k -1 or k + 2, . . . , r. The problem now decomposes into two subproblems: graphs H 1 and H 2 , such that H 1 should be embedded into segments 1 to k and H 2 should be embedded into segments k + 1 to r; moreover, we demand that the embeddings meet the guesses values of π on Y . The subproblems are in fact instances of extended DISTORTION problem and can be decomposed further in the same fashion until there are at most n/ log 3 (n) segments in one instance. The depth of this recurrence is O(log r) = O(log n), and each subproblem with at most n/ log 3 (n) can be solved by algorithm described in Theorem 4.4. Therefore, finally, we obtain an algorithm that works in O(4.383 n ) time and space and an algorithm that works in O(9.363 n ) time and polynomial space. Corollary A.5. For our choice of values for α, γ and c we obtain Proof. This is a straightforward corollary from Equation A.1. Corollary A.7. For our choice of values for β, γ and c we obtain Let us proceed to the main estimations. Lemma A.8. Let G be a path of length n + 1 -graph with Proof. Let us denote T (x) = 0 for x ≤ 0. This satisfies T (x) ≤ αc x-1 . We use the induction and start with calculating T (1) and T (2) manually. j, j + 1} due to the conditions for a partial bucket extension f . There is also one state with A = {v 0 }, ending up with T (2) = 3 • 4 + 3 + 1 = 16 < αc. Let us recursively count interesting prototypes for n ≥ 3. There is exactly one prototype (A, f ) with A = {v 0 }. Otherwise let k(A) > 0 be the smallest positive integer satisfying v k(A) ∈ A. Let us count the number of prototypes (A, f ), such that k(A) = k for fixed k. For k = 1 we have f (v 1 ) ∈ {j -1, j, j + 1}, and, having fixed value f (v 1 ), we have T (n -1) ways to choose A \ {v 0 } and f A\{v 0 } . For k > 1 we have jk + 1 ≤ f (v k ) ≤ j + k -1, due to the conditions for a partial bucket extension f , so we have (2k -1) ways to choose f (v k ) and T (nk) ways to choose A \ {v 0 , v 1 , . . . , v k-1 } and f A\{v 0 ,v 1 ,...,v k-1 } if k < n and 1 way if k = n. Therefore we have for n ≥ 3: Note that for n ≥ 3 we have 2n ≤ 6 αc 2 • αc n-1 , as we have an equality for n = 3 and the right side grows significantly faster than the left side for n ≥ 3. Using Corollary A.5 we obtain: Proof. Write the formula for T ′ using previously bounded T . We start with calculating T ′ (1) and T ′ (2) manually. If n = 1, if v 1 ∈ A we have f (v 1 ) ∈ {j, j + 1} and one prototype with A = ∅, so T ′ (1) = 3 ≤ β. If n = 2, we have one prototype with A = ∅, four prototypes if A = {v 2 } (since then f (v 2 ) ∈ {j -1, j, j + 1, j + 2}) and 2 • T (1) prototypes if v 1 ∈ A (since f (v 1 ) ∈ {j, j + 1}). Therefore T ′ (2) = 1 + 4 + 2 • 4 = 13 < βc. Let us assume n ≥ 3. There is exactly one prototype (A, f ) with A = ∅. Otherwise let k(A) > 0 be the smallest positive integer satisfying v k(A) ∈ A. Let us count the number of prototypes (A, f ) such that k(A) = k for fixed k. Note that, due to the conditions for a partial bucket extension f , jk + 1 ≤ f (v k ) ≤ j + k; there are 2k ways to choose f (v k ). There are T (nk) ways to choose A \ {v 0 , v 1 , . . . , v k-1 } and f A\{v 0 ,v 1 ,...,v k-1 } for k < n and 1 way for k = n, leading us to inequality Note that for n ≥ 3 we have 2n+1 ≤ 7 βc 2 •βc n-1 , as we have equality for n = 3 and the right side grows significantly faster than the left side for n ≥ 3. Therefore, using Corollary A.7, we obtain T ′ (n) ≤ βc n-1 at most γc |P |-2 ways to choose (A ∩ P, f | (A∪B)∩P ), and at least 0.4 of these possibilities satisfy v / ∈ A. Let us now fix one of such choices. Let G 1 , G 2 , . . . , G k be the connected components of G with removed P . Let V i be the set of vertices of G i and B i = B ∩ V i . For each 1 ≤ i ≤ k, we bound the number of possible choices for (A ∩ V i , f | (A∪B)∩V i ). If B i = ∅ (equivalently G i is a path) then one can choose (A ∩ V i , f | (A∪B)∩V i ) on T (|V i |) ≤ αc |V i |-1 or T ′ (|V i |) ≤ βc |V i |-1 ways, depending on whether v = v 0 ∈ A or v = v 0 / ∈ A (we use here Lemma A.8 or Lemma A.9 for v 0 = v and {v 1 , v 2 , . . . , v Otherwise, we use inductive assumption for G i with added root v. In this case we have at most δc |V i |-1 possibilities to choose (A ∩ V i , f | (A∪B)∩V i ). Let B = {1 ≤ i ≤ k : B i = ∅}, and A = {1, 2, . . . , k} \ B. If v ∈ A, the number of choices for all graphs G i is bounded by: ∈ A, the number of choices for all graphs G i is bounded by: Therefore, as α ≥ β, the total number of prototypes for G is bounded by Thus the bound is proven. Corollary A.13. The number of all prototypes satisfying f (v r ) ∈ {1, 2, . . . , N } is at most To finish up the proof of theorem 2.7, we need to show the following lemma. Lemma A.14. Fix B = B 0 . All prototypes can be generated in polynomial space and in O * (N c n ) time. The complexity analysis of our algorithm, in particular the proof in Appendix A, proves that the algorithm from[5] works in O(4.383 n ) time and space too. However, we do not state it as a new result in this paper, since analysis based on this approach will be published in the journal version of[5].