Running time analysis for algorithm A

Let N(F) denote the set of non-trivial fragments in F. We define the measure µ(F) of a given fragmentationF for (T, T⁰, S) as follows:

µ(F) = X

Note thatµ(F) =µ(F^rev) is trivial, so reversing a fragmentation does not change its measure.

Recall thatF^rev is a fragmentation for (T^rev, T^0rev, S).

Lemma 4.4.12. Let F¹, . . . ,F^t,F^t+1 be a series a fragmentations such that for eachi∈[t]

algorithmAobtainsFⁱ⁺¹fromFⁱ by applying a right split at an indexjiviolating Property`i

inFⁱ. LetHi denote the fragment of Fⁱ containingji. of Lemma 4.4.9. LetH_i⁰ be the non-trivial fragment obtained from Hi after the right split at ji. Now, by the choice of ji, Property`i is violated by ji in F<sup>i</sup>, but is not violated by any indexj<sup>0</sup> preceding ji in F<sup>i</sup>. In all cases where`i 6= 8, claim (1) of Lemma 4.4.9 implies that the indices preceding ji cannot violate Property`i in F<sup>i+1</sup>, yielding π(F<sup>i</sup>, Hi, `i) = 0 butπ(Fⁱ, H_i⁰, `i) = 1. Considering claims (2) and (3) of Lemma 4.4.9 again, (1) follows.

Observe that ifµ(F¹) =µ(F^t), then`i= 8 for everyi∈[t] follows directly from the above discussion. Suppose thatHi is a counterexample for (2), meaning thatHi does not contain

4.4. The Q-Q case 71 the indices of Hi+1. Since Fⁱ⁺¹ is obtained fromFⁱ by a right split, this can only happen ifHi+1 is a non-trivial fragment ofFⁱ different fromHi. Recall that a fragment B contains some index violating Property 8, if and only ifR(A, B) 6=∅ holds for some fragment A in the fragmentation. Hence,π(Fⁱ⁺¹, Hi+1,8) = 0 implies π(Fⁱ, Hi+1,8) = 0.

Since the algorithm always chooses the first index violating some property to branch on,ji

must be the smallest index that is LR-critical for some pair of fragments inFⁱ. Therefore,Hi

must precedeHi+1. But now, the choice ofji+1 indicatesπ(Fⁱ⁺¹, H_i⁰,8) = 1, whereH_i⁰ is the non-trivial fragment ofFⁱ⁺¹obtained by splittingHiatjiinFⁱ. Together withπ(Fⁱ, Hi,8) = 0 and statements (2) and (3) of Lemma 4.4.9, this showsµ(Fⁱ⁺¹)> µ(Fⁱ), a contradiction.

To prove (3), letH ∈ F¹contain everyji. LetP(H) denote the set of non-trivial fragments inF¹precedingH. For somei∈[t] and someF ∈P(H), letFidenote the unique non-trivial fragment of Fⁱ that contains some of the indices contained in F. We denote by P Rⁱ(H) those fragmentsF in P(H) for which R(Fi, Hi)6= ∅ holds in Fⁱ. Clearly,P Rⁱ(H)6=∅ for any i ∈ [t] by claim (2), and note also P Rⁱ⁺¹(H) ⊆ P Rⁱ(H). If F ∈ P Rⁱ(H), then we definedⁱ(F) as follows. If L(Fi, Hi) =∅ inFⁱ, then lety_i^Lbe the first index contained inFi

minus one, otherwise lety_i^L have the value of L^max(Fi, Hi) inFⁱ. Also, let y_i^R be the value ofR^min(Fi, Hi) inFⁱ. We setdⁱ(F) =y^R_i −y^L_i.

LetA∈P Rⁱ⁺¹(H) denote a non-trivial fragment such thatji is LR-critical for (Ai, Hi).

We showdⁱ⁺¹(A)> dⁱ(A). Clearly,ji is either L-critical or R-critical for (Ai, Hi). First, let us assume thatji is L-critical for (Ai, Hi). Observe that the definition of L-critical indices implies that for any vertexv starting atL^max(Ai, Hi) and contained inL(Ai, Hi) inFⁱ, we knowQ^right_r⁰ (v)≥ji. SinceFⁱ⁺¹ is obtained by performing the right split atji in Fⁱ, every index of Hi+1 precedes ji, implying that such a v can not be contained in L(Ai+1, Hi+1) in Fⁱ⁺¹. Thus,L^max(Ai+1, Hi+1)6=L^max(Ai, Hi), from whichy^L_i+1 < y_i^L follows. Therefore, we havedⁱ⁺¹(A)> dⁱ(A).

Second, let us assume thatjiis R-critical for (Ai, Hi). Using the definition of R-criticality, implies that for any vertexv starting atR^min(Ai, Hi) and contained in R(Ai, Hi) inFⁱ, we know Q^right_r⁰ (v) ≥ji. Again, we know that every index of Hi+1 precedes ji. From this, we have thatv can not be contained inR(Ai+1, Hi+1) in Fⁱ⁺¹, implyingy_i+1^R > y^R_i . Therefore, we havedⁱ⁺¹(A)> dⁱ(A) in this case as well.

Now, we claim that 1 ≤ dⁱ(A) ≤ σ(A) for any A ∈ P Rⁱ(H). First, it is clear that for any ` < 8, Property ` holds for each index both in Fⁱ and in the reversed fragmenta-tionFi^rev, as otherwise the algorithm would branch on an index violating Property`. Thus, L^max(Ai, Hi)≥ R^min(Ai, Hi) can not happen, as this would mean that there is a conflict-inducing index inHi for (Ai, Hi), violating Property 7. This directly implies 1≤dⁱ(A).

Second, assumedⁱ(A) =y_i^R−y_i^L > σ(A). This implies thath=y_i^R−σ(A) is contained inAi, but no vertex ofL(Ai, Hi)∪R(Ai, Hi) starts inh. However, by Properties 3 and 5 fory^R_i , we know that some vertex in M_r⁺((y_i^R)_left) = M_r⁺(hright) ends Hi. Using these properties for h^rev in the reversed instance, we obtain that some vertex v in M_r⁺⁰(h) must also end in Hi. By Property 5 for h, v must be contained in one of the sets L(Ai, Hi), R(Ai, Hi), X(Ai, Hi). But y^L_i < h < y^R_i , so we obtain v ∈ X(Ai, Hi). Therefore, some index in Hi

violates Property 6, a contradiction.

Now, observe that for anyi ∈[t], ji is LR-critical for some (Ai, Hi) withA ∈P Rⁱ(H).

IfA ∈P Rⁱ⁺¹(H) as well, then dⁱ⁺¹(A) > dⁱ(A). By our bounds on dⁱ(A), this yields that there can be at mostσ(A) indicesiwhere ji is LR-critical for (Ai, Hi). (Here we also used that dⁱ(A) can not decrease, by its definition.) This clearly implies t ≤ P

F∈P(H)σ(F) = δ(H).

To finish the proof, we showδ(H)≤k. Letb⁰be the last index preceding the indices inH, and letb=b⁰+δ(H). Recall thatφS(B_r⁺0(1, b⁰)) =B_r⁺(1, b)\S by Proposition 4.4.4. Using that Properties 1 and 3 hold for every index in [m⁰] and thatB_r⁺(i)6=∅by Proposition 4.1.2

for anyi∈[m], we obtain

Now, we can state the key properties of algorithmA, which prove Theorem 4.3.1.

Lemma 4.4.13. Given an input(G⁰, G)where|V(G⁰)|=nand|V(G)|=n+k, algorithmA either produces a reduced input in O(n) time, or branches into at most k^O(k3) such that in each branch it either correctly refuses the instance, or outputs an independent subproblem or a necessary set of size at most2k+ 1. Moreover, each branch takesO(n)time.

Proof. Let us overview the steps of algorithm A. First, it tries to apply the reduction rules described in Section 4.3.2. In this phase, it either outputs a reduced input in linear time, or it may branch into at most (4k+ 1)2^4k(k(7k/2 + 8) + 1) = 2^O(k) branches. In each branch it either correctly outputs ’No’, outputs a necessary set of size at most 2, or outputs an independent subproblem having parameter at mostk−1 but at least 1. These steps can be done in linear time, as argued in Section 4.3.2.

If none of the reductions in Section 4.3.2 can be applied, then A first checks whether a reduced input can be output by using Lemma 4.4.2. If not, then it branches into 3 directions, according to whetherS is local, and if not, whether the children ofr⁰ should be reversed to achieve the properties of Lemma 4.4.1. In the first branch, it outputs a necessary set of size at most 2. In the other two branches, it checks whether the annotated fragmentationAF0

produced in the beginning is proper. While the annotated fragmentation is not proper,A chooses the smallest`and the smallest indexj violating Property `(maybe in the reversed instance), and branches into at most 2(k+1)²−1 directions. In these branches,Aeither mod-ifies the actual annotated fragmentation or stops by outputting an independent subproblem, a necessary set of size at most 2k+ 1, or rejecting.

Let us consider a sequence oftsuch branchings performed byA, and letAF0, AF1, . . . , AFt

be the sequence of annotated fragmentations produced in this process. (We interpret these as annotated fragmentations for (T, T⁰, S) and not for (T^rev, T^0rev, S).) Let us call a con-tinuous subsequence S of AF0, AF1, . . . , AFt a segment, if each annotated fragmentation in S has the same number of non-trivial fragments, and S is maximal with respect to this property. By Lemma 4.4.5, the algorithm can reject if there are more than 2k non-trivial fragments in a fragmentation, soAF0, AF1, . . . , AFtcan contain at most 2ksegments.

Let S = AFt1, AFt1+1, . . . , AFt2 be such a segment. Clearly, each AFh (t1 < h ≤ t2) is obtained from AFh−1 by performing a right split either in the original or in the reversed instance (the latter meaning thatAF_h^rev is obtained fromAF_h^rev₋₁ by a right split).

LetAFpbe the first 9-proper annotated fragmentation in the segment. By Lemma 4.4.12, each subsequence ofAFt1, . . . , AFp where the measure does not increase can have length at mostk. (The measure of an annotated fragmentation is the measure of its fragmentation.) By (2) of Lemma 4.4.12, AFt1 has a non-trivial fragment containing each of those indices for which the algorithm performed a branching (because of Property 8) in someAFh, t1 ≤ h≤p. Taking into account that the number of non-trivial fragments can not exceed 2k, but branchings can also happen in the reversed instance, we obtain that there can be at most 4k maximal subsequences inAFt1, . . . , AFp of length at least 2 where the measure is constant.

Using Lemma 4.4.5, we get thatµ(AFp)≤36k, implyingp≤t1+ 4k²+ 36k.

4.4. The Q-Q case 73 Clearly, A obtains AFp+1, AFp+2, . . . , AFt2 while trying to ensure Property 10, by per-forming right splits in the original instance. Observe that ifAobtains AFh(p+ 1≤h≤t2) by applying a right split at j, then by the choice of j, Property 10 holds for each in-dex j⁰ ≤ j in any AFh⁰ where h⁰ ≥ h. This, together with Lemma 4.4.5 implies that A can perform at most 2k such branchings, implying that t2 ≤ p+ 2k ≤t1+ 4k²+ 38k. Al-together, this impliest≤2k(4k²+ 38k), proving that the maximum length of a sequence of branchings performed by Ain order to obtain a proper annotated fragmentation can be at most 8k³+ 76k²=O(k³).

Essentially, this means that the search tree thatAinvestigates has height at mostO(k³).

Since one branching results in at most 2(k+ 1)² −1 directions, we obtain that the to-tal number of resulting branches in a run of algorithm A can be bounded by some func-tions f(k) = k^O(k3). In each of these branches, if A does not stop, then it has a proper annotated fragmentation (F, U). After this, algorithmAdoes not perform any more branch-ings. Instead, it applies Lemma 4.4.10 repeatedly. If the algorithm reaches a state where Lemma 4.4.10 does not apply, then it outputs a solution in linear time using Lemma 4.4.11.

It is easy to verify that each branch can be performed in linear time. The only non-trivial task is to show that the repeated application of Lemma 4.4.10 can be implemented in linear time, but this easily follows from the fact that none of the conditions of Lemma 4.4.10 can be applied twice for a block [a, b].