 # Finding Independent Transversals Efficiently

We give an efficient algorithm that, given a graph G and a partition V_1,...,V_m of its vertex set, finds either an independent transversal (an independent set {v_1,...,v_m} in G such that v_i∈ V_i for each i), or a subset B of vertex classes such that the subgraph of G induced by B has a small dominating set. A non-algorithmic proof of this result has been known for a number of years and has been applied to solve many other problems. Thus we are able to give algorithmic versions of many of these applications, a few of which we describe explicitly here.

## Authors

##### This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

## 1 Introduction

Let be a graph whose vertex set is partitioned into classes . An independent transversal (IT) of with respect to the given vertex partition is an independent set in such that for each . This is a very general notion, and many combinatorial problems can be formulated by asking if a given graph with a given vertex partition has an IT. Indeed the SAT problem can be formulated in these terms (see e.g. ), and so we cannot expect to find an efficient characterisation of those for which an IT exists. However, there are now various known results giving sufficient conditions for the existence of an IT. One of the most easily stated and most frequently applied is the following result from [31, 32].

###### Theorem 1.

Let be a graph with maximum degree . Then in any vertex partition of where there exists an independent transversal of .

Theorem 1 answered the question of how large the vertex classes need to be, in terms of the maximum degree, to guarantee the existence of an IT in . This question was first introduced and studied in 1975 by Bollobás, Erdős and Szemerédi in , and further progress was contributed over the years by many authors. In particular, linear upper bounds in terms of were given by Alon  (in an early application of the Lovász Local Lemma ) and independently Fellows , and a later application of the Local Lemma gave that class size is sufficient (see e.g. Alon and Spencer ). Further refining this approach, Bissacot, Fernández, Procacci and Scoppola  improved this to . Work on lower bounds included results of Jin , Yuster , and Alon , and in 2006 Szabó and Tardos  gave constructions for every in which for each but there is no IT. Therefore Theorem 1 is best possible for every value of . A more precise version of Theorem 1 (involving also the number of vertex classes) is given in .

Theorem 1 is an immediate consequence of a more general statement described in terms of domination (stated explicitly in , although it follows easily from the argument in ). We say that a subset dominates a subgraph of if for all , there exists for some . (This definition of domination is quite often referred to as strong domination, but since it is the only notion of domination that we will refer to in this paper, we will use the simpler term.) For a vertex partition of and a subset of , we write for the subgraph of induced by the union of the classes in .

###### Theorem 2.

Let be a graph with a vertex partition . Suppose that, for each , the subgraph is not dominated in by any set of size at most . Then has an IT.

To see that Theorem 2 implies Theorem 1, simply note that if the union of vertex classes in contains a total of vertices then cannot be dominated by vertices of degree at most .

In fact the proof of Theorem 2 shows that if does not have an IT then there exists such that is dominated by the vertex set of a constellation for .

###### Definition 3.

Let be a set of vertex classes in a vertex-partitioned graph . A constellation for is an induced subgraph of , whose components are stars with at least two vertices, each with a centre and a nonempty set of leaves distinct from its centre. The set of all leaves of forms an IT of vertex classes of .

Note that if is a constellation for then . Figure 1 shows an example of a constellation.

Theorem 2 (often in the form of Theorem 1) has been applied to obtain many results in various fields, including graph theory (e.g. list colouring, strong colouring, delay edge colouring, circular colouring, various graph partitioning and special independent set problems), hypergraphs (e.g. hypergraph matching), group theory (e.g. generators in linear groups), and theoretical computer science (e.g. job scheduling and other resource allocation problems). Unfortunately, the proofs of Theorems 1 and 2 are not algorithmic. For certain applications it is enough to know that class sizes of in Theorem 1 guarantee an IT for some constant , so for these one could obtain algorithmic versions using (for example) the algorithmic Lovász Local Lemma ([17, 45, 46]). However, for many other applications, having the best possible value of the constant is important. This therefore raises the question of how much the hypotheses in Theorems 2 and 1 need to be strengthened in order to guarantee that an IT can be found efficiently, thereby giving algorithmic proofs of these applications with the constants being as close as possible to their optimal values.

Most of the known results on this question have focused on Theorem 1, and have been obtained as applications of algorithmic versions of the Lovász Local Lemma or its lopsided variant. These include the original algorithm of Beck  and its improvements (see e.g. [7, 44, 21, 50, 18]) as well as the resampling algorithm of Moser and Tardos  and its improvements (see e.g. [41, 47, 42, 29, 1, 28]. In particular, using the Moser-Tardos approach (and based on [18, 47]), Harris and Srinivasan  gave a randomized algorithm that finds an IT in expected time in graphs with class size . The current best result for polynomial expected time is due to Harris  who improved the bound on the class size to . Deterministic algorithms based on derandomizing the Moser-Tardos algorithm have also been studied, but they require the class size be for some large constant in order to find an IT efficiently [24, 27]. Some of these deterministic algorithms are known to be parallelizable [20, 27].

In this paper, we address the algorithmic IT question for a large class of graphs, without using the Lovász Local Lemma or any of its variants. A graph with vertex partition is said to be -claw-free with respect to if no vertex of has independent neighbours in distinct vertex classes. Our main theorem is as follows.

###### Theorem 4.

Let and be given. Then there exists an algorithm that takes as input any graph with vertex partition such that is -claw-free with respect to and finds, in time polynomial in , either:

1. an independent transversal in , or

2. a set of vertex classes and a set of vertices of such that dominates in and . Moreover contains for a constellation of some , where .

Note in particular that any graph with maximum degree is -claw-free with respect to any partition. Thus taking and gives the following algorithmic version of Theorem 1.

###### Corollary 5.

Let . Then there exists an algorithm that takes as input any graph with maximum degree and vertex classes such that for each and finds, in time polynomial in , an independent transversal in .

Therefore only a slight strengthening of the hypotheses is required to make these results algorithmic.

The proof of Theorem 4 explicitly describes the algorithm . It uses ideas from the original (non-algorithmic) proof of Theorem 2 (see [31, 37]), and modifications of several key notions (including that of “lazy updates”) introduced by Annamalai in [12, 14], who gave an algorithmic version of the specific case of matchings in bipartite hypergraphs. This appears as Theorem 22 in Section 7, and is relevant to other well-studied problems such as the restricted max-min fair allocation problem (also known as the Santa Claus problem), see [15, 16]. Theorem 4 is a broad generalisation of Theorem 22 which, because of the large number of applications of Theorems 1 and 2 over the years, has algorithmic consequences for many results in a wide variety of settings. In addition to describing the case of bipartite hypergraph matching, in Section 7 we outline algorithmic versions of a few more selected applications of Theorem 2 that follow from our results. Here we have chosen to discuss circular chromatic index (Kaiser, Král and Škrekovski ), strong colouring (Aharoni, Berger and Ziv ), and hitting sets for maximum cliques (King ), but there are many other examples, some of which are described in detail in . In each case, the algorithmic version is only slightly weaker than the original result due to the error introduced in Theorem 4. In fact for some applications (for example the results on circular chromatic index and hitting sets for maximum cliques) no weakening at all is needed.

It should be noted that the degree of the polynomial in depends on and in Theorem 4, and on in Corollary 5

. This dependence is estimated explicitly in Lemma

20. We remark that, for simplicity, in this paper we make no attempt to optimize the running time of our algorithms in terms of these parameters.

This paper is organised as follows. In Section 2 we give an overview of the proof of our main result, by first outlining the proof of Theorem 2 (which gives an exponential algorithm) and then sketching how we modify it to make the algorithm efficient. Our algorithms are described in detail in Section 4, after definitions and other preliminary material in Section 3. The main components of the algorithm are analysed in Section 5 and the running time in Section 6. Section 7 is devoted to applications of our results, and Section 8 contains concluding remarks and open questions.

## 2 Setup and Overview

Throughout this paper we will work with the following notation and assumptions. Let be a graph and let be a vertex partition of such that is -claw-free with respect to . By deleting the edges between vertices in the same vertex class and considering the resulting graph , we may assume without loss of generality that each vertex class is an independent set of vertices. This is because a set is an IT of if and only if is an IT of . Since the case is trivial we may assume from now on that .

Our algorithms will seek to construct an IT of step by step, by augmenting a previously constructed partial independent transversal (PIT) of with respect to the given vertex partition. A PIT is simply an independent set in (of size less than ) such that no two vertices of are in the same vertex class.

Note that any isolated vertex can be added to any PIT that does not contain a vertex in its vertex class. Thus, we may remove the vertex classes from that contain at least one isolated vertex and consider the induced subgraph of the remaining vertex classes as under the same partition of these vertices. We will therefore assume from now on that does not contain an isolated vertex. In particular, we may also assume that .

We denote the vertex class that contains the vertex by and the set of vertex classes containing by . We write for the neighbourhood in of , and for . We denote by .

To give an overview of the proof of Theorem 4, we first sketch the proof of Theorem 2. The proof does give a procedure for constructing an IT, but (as we will note after the sketch) the number of steps could be as large as .

###### Sketch of the proof of Theorem 2:.

Let be a PIT and be a vertex class such that . We aim to alter until it can be augmented by a vertex of .

We build a “tree-like structure” as follows (here in fact will be a vertex set inducing a forest of stars in ). Choose and set . If then improve by adding to , and stop. Otherwise add to .

In the general -th step: it can easily be shown that . Thus by assumption the subgraph of induced by is not dominated by . Therefore there exists a vertex of that is not adjacent to any vertex in . Choose such a vertex arbitrarily.

If then improve by adding to and removing the -vertex in the class of . This forms a new PIT , and is an improvement in the following sense: it reduces where was added to because it was in in an earlier step. Truncate to .

Otherwise add and to . Thus increases by and increases by , thus maintaining . See Figure 1 for (the set of vertices shown) and (the set of classes enclosed by the dotted border). Note that is a constellation for .

At each step we either grow OR reduce for some , UNTIL the current can be extended to include a vertex of . Thus progress can be measured by a

signature vector

 (dM(x1),…,dM(xt),∞)

that has length at most since each is a nonempty subset of and all such sets are mutually disjoint. Each step reduces the lexicographic order of the signature vector. Thus the process terminates, and we succeed in extending to a larger PIT and eventually to an IT. ∎

The drawback of the above procedure is that the number of signature vectors (and hence the number of steps) could potentially be as large as , where is -claw-free. To make this approach into an efficient algorithm, we make three main modifications. Here the idea of “lazy updates” from [12, 14] is used, which essentially amounts to performing updates in “clusters” (large subsets of vertices) rather than at the level of individual vertices (that change the quantities only one at a time). These modifications are as follows.

1. Maintain layers: at each growth step, instead of choosing arbitrarily, choose it to be a vertex in a class at smallest possible “distance” from the root class , similar to a breadth-first search. Vertices added into classes at the same distance from are in the same layer (see Figure 2).

2. Update in “clusters”: instead of updating when a single satisfies , update only when at least a positive proportion of an entire layer satisfies . Discard later layers.

3. Rebuild layers in “clusters”: after an update, add new vertices to a layer of only if doing so would add a proportion of that layer. Then discard later layers.

The parameter is a fixed positive constant, chosen to be small enough with respect to the parameters and . The extra factor in (2) of Theorem 4 is enough to guarantee that the same proof idea as for Theorem 2 finds an IT in , UNLESS (as in that proof) at some point in the construction of , (a subset that is almost all of) is dominated by (plus a certain very small set of additional vertices, necessary to deal with the error introduced by the lazy updates in Modifications 2 and 3). This dominating set will have total size less than , resulting in Output (2) in Theorem 4. Thus for the rest of this section we will assume that this never occurs, and in particular that a positive proportion (depending on ) of the vertices of are not dominated by .

A consequence of maintaining layers is that the undominated vertices in tend to be “pushed” towards the bottom layer. This results in the set of vertices of in the bottom layer having size a positive proportion of , where again depends only on and (see Lemma 15). This implies that the total number of layers is always logarithmic in (Lemma 16), since with each new layer the total size of increases by a fixed factor larger than one.

Updating in clusters and rebuilding layers in clusters allow a different signature vector, that measures sizes of layers rather than degrees of individual vertices . It has just two entries per layer: the first is essentially - where is the number of vertices in that layer, and the second is essentially where is the total size of their neighbourhoods in . Updating in a cluster (Modification 2) decreases the value of for a layer by a positive proportion. Rebuilding a layer in a cluster (Modification 3) increases the value of for a layer by a positive proportion. Hence (with suitably chosen bases for the logarithms) these updates always decrease the relevant entry by an integer amount. Therefore, as in the proof of Theorem 2, each update decreases the signature vector lexicographically (Lemma 18).

Since the length of the signature vector is proportional to the number of layers, as noted above this is logarithmic in . The entries are also of the order . While this gives a very significant improvement over the signature vector from the proof of Theorem 2, it still does not quite give a polynomial number of signature vectors. However, as in [12, 14] it can be shown with a suitable alteration of the above definition (Definition 17), each signature vector can be associated to a partition of an integer of magnitude . It will follow that the number of signature vectors, and hence the number of steps in the algorithm, is polynomial in (Lemma 20).

## 3 Preliminaries

In this section we formalise the main notions we will need. Much of the terminology in this section follows that of [12, 14]. Let and be as in Section 2. For the definitions that follow, consider a PIT of .

###### Definition 6.

A vertex blocks a vertex if , .

###### Definition 7.

A vertex is immediately addable with respect to if and it has no vertices in blocking it. For , denotes the set of vertices in that are immediately addable with respect to .

###### Definition 8.

A layer of with respect to a PIT is a pair where:

1. ,

2. is an independent set,

3. is the set of blocking vertices of , and

4. every is adjacent to exactly one vertex from .

For an example of a layer, refer to Figure 2. Note that is also an independent set since is an independent set.

###### Definition 9.

Let be a PIT in and let be a vertex class in the vertex partition of that does not contain a vertex in . An alternating tree with respect to and is a tuple where such that:

1. and ,

2. is a layer for each ,

3. and for all , and

4. for all , .

We call the root of .

Figure 2 provides an example of an alternating tree.

Let be an alternating tree of with respect to a PIT and root . We define to be the union of the in , i.e. . Similarly, we define . Note that is the set of vertex classes intersecting . It follows from Definitions 8 and 9 that the subgraph of induced by is a constellation for (see Figures 1 and 2).

Our algorithm will make use of fixed constants , , and which will be chosen in advance and depend only on the input constants and . The following notion formalises a suitable choice.

###### Definition 10.

Let and be given. We say a tuple of positive real numbers is feasible for if the following hold:

1. ,

2. , and

3. .

For example, is feasible for when and . As mentioned in the introduction, we make no attempt here to choose the constants to optimize the running time (see Lemma 20).

The following two definitions will depend on the fixed constants and .

###### Definition 11.

Let be an alternating tree of with respect to a PIT and root and let . A vertex is an addable vertex for , , and if , has fewer than vertices in , and there does not exist a vertex such that .

###### Definition 12.

A layer is collapsible if .

## 4 Algorithms

Recall that is an -claw-free graph with respect to vertex partition . Let be a PIT in and let be a vertex class in the vertex partition of that does not contain a vertex in . The main idea of the algorithm in Theorem 4 is to perform a series of modifications to that will allow us to augment it with a vertex in . If we are not successful then we will find a subset of classes (based on an alternating tree of ) that has a small dominating set.

To prove Theorem 4, we will provide (in Section 6) an algorithm FindITorBD that satisfies the requirements for in Theorem 4. In the following subsections, we describe three algorithms that are used by FindITorBD. The first two algorithms, called BuildLayer and SuperposedBuild, are used as subroutines in the third algorithm, called GrowTransversal. GrowTransversal appears as a subroutine of FindITorBD.

Let be an alternating tree of with respect to and . Let , , and be fixed constants chosen in advance so that is feasible for (see Definition 10).

### 4.1 BuildLayer

BuildLayer is a subroutine in the main algorithm for augmenting that helps construct new layers for . The function takes as inputs and some ( can be thought of as a “partially built”  layer). It then creates a new layer by augmenting and and returning the resulting pair .

1:function BuildLayer()
2:     while there is a vertex that is addable for , , and  do
3:
4:
5:     end while
6:     return
7:end function

### 4.2 SuperposedBuild

SuperposedBuild is a subroutine in the main algorithm for augmenting that, after a modification of occurs in the algorithm, modifies so that it remains an alternating tree with respect to the new PIT . SuperposedBuild possibly augments by adding some vertices that are no longer blocked due to the modification of . The function takes as inputs the current and its number of layers . It then performs some tests on the layers of , to see if any layer could be substantially enlarged, and returns a possibly modified alternating tree to replace for the next iteration of the main algorithm as well as the number of layers in the returned alternating tree.

1:function SuperposedBuild()
2:
3:     while  do
4:
5:         if  then
6:
7:
8:
9:
10:         end if
11:
12:     end while
13:     return
14:end function

### 4.3 GrowTransversal

GrowTransversal is the main algorithm for augmenting . It takes as inputs and and performs a series of modifications to until either a vertex in is added to or an iteration constructs a layer with too small an relative to the size of . When GrowTransversal terminates, it returns , , and a flag variable as . The variable is set to if GrowTransversal terminates due to an iteration constructing a layer with at most vertices in and is set to if GrowTransversal successfully augments with a vertex in . If GrowTransversal returns , we will show in the next section that contains a subset of vertex classes whose vertices are dominated by a set of fewer than vertices with the properties stated in Theorem 4.

1:function GrowTransversal()
2:
3:
4:
5:
6:
7:     while  do
8:
9:
10:
11:         if  then
12:              return and terminate
13:         else
14:
15:              while  do
16:                  if  then
17:                       Augment with a vertex from
18:                       return and terminate
19:                  else
20:                       for all  such that  do
21:                            for some arbitrary
22:
23:                       end for
24:                  end if
25:
26:
27:
28:              end while
29:         end if
30:     end while
31:end function

The GrowTransversal algorithm begins by initializing the alternating tree with respect to and its number of layers . While does not contain a vertex in the PIT, the algorithm repeats a building layer operation (line 8) followed by a loop of collapsing operations (lines 15-28) that modify when enough immediately addable vertices with respect to are present in the newly constructed layer. Figure 3 shows the process of collapsing a layer (lines 20-23).

As can be seen in Figure 3, performing one collapse operation can result in more vertices becoming immediately addable with respect to the new in a previous layer. Hence one collapse operation can lead to a cascade of collapse operations being performed on layers of . Also, any collapse operation can modify in such a way that SuperposedBuild can modify a layer of to contain a significantly larger number of vertices ( and so replacing by adds at least vertices to the layer). These modifications to a layer (which is the final layer of the tree returned by SuperposedBuild) may still leave it collapsible, so more collapse operations may be possible if SuperposedBuild modifies a layer of . Thus, for the at the conclusion of line 28 to remain an alternating tree with respect to after all these modifications are made to , GrowTransversal removes all layers of constructed after the earliest layer that contains a vertex class where is modified (lines 25-27). This leaves the resulting as an alternating tree with respect to the modified .

Due to these operations, at the beginning and end of each iteration of the main loop of GrowTransversal (which starts in line 7), remains a PIT and remains an alternating tree with respect to . Also, the modifications to do not change the set of vertex classes containing vertices in (lines 20-23) unless is collapsible. In this case, a vertex in , which is therefore in , is added to (lines 15-18) and so is added to the set of vertex classes covered by the PIT. As this is the goal of GrowTransversal, the algorithm returns and terminates (see line 18).

The algorithm also terminates if, at the start of some iteration, BuildLayer produces a layer whose is not sufficiently large with respect to the number of vertex classes already in , i.e. (see lines 11-12). If GrowTransversal terminates because of this, GrowTransversal returns , which distinguishes this case from when the algorithm terminates because it successfully augments to include a vertex of . We will show in the next section that given an alternating tree with respect to and such that , there exists some set of the vertex classes in such that is dominated by a set of vertices with the properties stated in Theorem 4. Our analysis will provide a specific and its corresponding given that GrowTransversal returns .

## 5 Analysis

Recall from Section 3 that we can assume is an -claw-free graph with respect to vertex partition , each vertex class is an independent set of vertices, , and . Also, recall from Section 4 that , , and are fixed constants such that is feasible for .

For concreteness, we may also assume that the vertices of the graph have been assigned some arbitrary but fixed ordering, and that vertices are processed by our algorithms subject to this ordering. For example, we assume that adds vertices to and in order, i.e. during an iteration of the while loop in BuildLayer, the addable vertex with the lowest index in the ordering is the vertex chosen to be in line 3. Similarly we may assume that the vertex in line 21 of GrowTransversal is chosen to be the vertex in with the lowest index in the ordering. The proof of Proposition 15 will also use this convention.

###### Lemma 13.

Let and be the alternating tree and partial independent transversal at the beginning of some iteration of the while loop in line of GrowTransversal. Then none of the layers are collapsible. Hence for each .

###### Proof:.

Suppose the statement holds at the beginning of the current iteration. In lines and of GrowTransversal, is constructed. If GrowTransversal does not terminate and is not collapsible, then the claim follows for the beginning of the next iteration since none of the earlier layers were modified in the current iteration.

If GrowTransversal does not terminate and is collapsible, then let be the alternating tree with respect to that results from the loop of collapsing operations where (i.e. is the alternating tree after lines 15-28 are completed). Unless the algorithm terminates, (lines 14-17).

Each time a collapse operation is performed (lines 20-23), the number of layers in is reduced (line 25). Also, if SuperposedBuild modifies in line 27, the number of layers of is reduced or stays the same. Thus, layers are not changed by the loop of collapsing operations and so remain unchanged throughout the current iteration. Layer may be modified in lines 21, 22, and 27. However, cannot be collapsible since it is the final layer in after the loop of collapsing operations terminates. Hence none of the layers in an alternating tree are collapsible at the end of an iteration of the while loop in line 7 (unless the algorithm terminates during the iteration).

Since the claim holds for the first iteration of the while loop in line 7, the statement follows by induction on the number of iterations of this loop in GrowTransversal. As is a layer for each , contains all blocking vertices of all vertices in and every vertex in is adjacent to exactly one vertex in by construction. Thus, there are at most vertices in and at most vertices in for each layer . Hence for each .∎

###### Lemma 14.

Let and be the alternating tree and partial independent transversal at the beginning of some iteration of the while loop in line of GrowTransversal. Then for each ,

 (X′i,Y′i):=BuildLayer((L0,…,Li−1),Xi,Yi)

satisfies .

###### Proof:.

Consider layer at the beginning of the current iteration for some . During the iteration that was constructed by either BuildLayer in line 8 or SuperposedBuild in line 27, an (additional) application of SuperposedBuild could not increase the size of (both functions created to be as large as possible with respect to in that iteration).

Suppose no layer built during the iterations between when was constructed and the current iteration is collapsible, i.e. the condition of line 15 is not met between the iteration was constructed and the current iteration of GrowTransversal. Then, since is not changed during the intervening iterations, SuperposedBuild does not increase the size of .

Now suppose some layer built during the intervening iterations was collapsible. Note that the index of the collapsible layer must be greater than as otherwise would be discarded (lines 25-27). Thus, for each such that is collapsible, SuperposedBuild tries to augment by at least a proportion of its size. However, since is a layer in at the start of the current iteration, SuperposedBuild does not succeed in changing . Hence BuildLayer does not increase the number of vertices in by . ∎

###### Lemma 15.

Assume is feasible for . Let and be the alternating tree with root vertex and partial independent transversal at the beginning of some iteration of the while loop in line of GrowTransversal. Then either

1. when is constructed in line 8 of GrowTransversal we have , or

2. GrowTransversal terminates in line 12, and there exists a subset of the set such that is dominated by a set of vertices in of size less than . Moreover is a constellation for and contains , where .

###### Proof:.

Suppose that after is constructed in line 8, . For each , let . Define algorithmically by performing the following steps in order:

1. .

2. Remove all vertex classes of that contain vertices in .

3. Remove all vertex classes in .

Clearly , and is a constellation for (as noted after Definition 9).

###### Claim 1.

We have

 |B|−1≥[1−1U(1+μU1−μ+ρ)]|Y≤ℓ|.
###### Proof:.

The vertex classes in include the vertex classes of that do not contain vertices in and do not contain any addable vertices for , , and for all . We use these facts to bound from below as follows.

Recall that . The set of vertex classes in that contain vertices in has size at most . By Lemma 14, for each . As , this implies that there are at most vertices in . Thus for all and so . Also by Lemma 13, and by the assumption, . Therefore,

 |B| ≥|A(Y≤ℓ)|−|AU|−∣∣ ∣∣ℓ⋃i=1A(X′i∖Xi)∣∣ ∣∣ ≥|A(Y≤ℓ)|−1U|X≤ℓ+1|−μ|X≤ℓ| =(|Y≤ℓ|+1)−(1U|X≤ℓ|+1U|Xℓ+1|+μ|X≤ℓ|) ≥|Y≤ℓ|+1−[(1U+μ)|X≤ℓ|+ρU|Y≤ℓ|] ≥|Y≤ℓ|+1−[(1U+μ)(11−μ)|Y≤ℓ|+ρU|Y≤ℓ|] =1+[1−1U(1+μU1−μ+ρ)]|Y≤ℓ|.

Let denote the set of vertices in the vertex classes of and let

 W=X′≤ℓ∪Y′≤ℓ∪Xℓ+1∪Yℓ+1.
###### Claim 2.

The set dominates .

###### Proof:.

Let . By (iii) we have that .

Suppose . Then . If for some , then the construction of and by BuildLayer implies that has a neighbour in (lines 3-4 of BuildLayer). Hence . Similarly, if , then has a neighbour in (lines 3-4 of BuildLayer). If for some , then since , has a neighbour that blocks . By the construction of (lines 2-4 of BuildLayer), and so . Therefore, every has a neighbour in . Thus we may assume .

Note that each vertex class in has at most one vertex in and that these vertices are in , hence . Since