Reconstructing a SuperGeneTree minimizing reconciliation

A fundamental task in evolutionary biology is to combine a collection of rooted trees on partial, possibly overlapping, sets of data, into a single rooted tree on the full set of data. This is the goal of supertree methods, mainly designed and used for the purpose of reconstructing a species supertree from a set of species trees (see overviews of early methods in [4–6], and more recent methods in [2, 10, 21, 24, 25, 28, 29]).

Ideally, the combined supertree should "display" each of the input tree, in the sense that by restricting the supertree to the leaf set of an input tree, we obtain the same input tree. However, this is not always possible, as the input trees may contain conflicting phylogenetic information. Note that considering a set of input trees that are not all compatible leads to the questions of correcting input gene trees or finding a subset of compatible input trees or subtrees [26]. Here, we leave open these questions and study the more direct formulation of the supertree problem that is to consider a set of compatible input trees and find a supertree displaying them all. The BUILD algorithm by Aho et al. [1] can be used to test, in polynomial time, whether a collection of rooted trees is compatible, and if so, construct a compatible supertree, not necessarily fully resolved. This algorithm has been generalized in [9, 20] to output all compatible supertrees, and adapted in [27] to output all minimally resolved compatible supertrees.

Although supertree methods are classically applied to the construction of species trees, they can be used as well for the purpose of constructing gene trees. Several gene tree databases are available (see for example Ensembl Compara [30], Hogenom [22], Phog [11], MetaPHOrs [23], PhylomeDB [14], Panther[19]). For a gene family of interest, many different gene trees can therefore be available, and finding one single supertree displaying them all leads to a supertree question. On the other hand, given a gene of interest, a homology-based search tool is usually used to output all homologs in a set of genomes. The resulting gene family may be very large, involving distant gene sequences that may be hard to align, leading to weakly supported trees - or even worse, highly supported gene trees that are in fact incorrect. A standard way of reducing such errors is then to use a clustering algorithm based on sequence similarity, such as OrthoMCL [18], InParanoid [3], Proteinortho [17] or many others (see Quest for Orthologs links at http://questfororthologs.org/), to group genes into smaller sets of orthologs or inparalogs (paralogs that arose after a given speciation). Trees obtained for such partial gene families can then be combined by using a supertree method.

Considering input trees as parts of gene trees rather than as parts of species trees does not make any difference regarding the compatibility test procedure. However, for reconstructing a compatible "super gene tree", if a species tree is known for the taxa of interest, then it can be used as an additional information to choose among all possible supertrees displaying the input partial gene trees. Indeed, a natural optimization criterion is to minimize the reconciliation cost, i.e. either the duplication or the duplication plus loss cost, induced by the output tree. We call the problem of finding a compatible supertree minimizing a reconciliation cost the supergenetree problem.

In this paper, we first show how the exact methods developed for the supertree problem can be adapted to the supergenetree problem. As for the original algorithms, all the extensions have also exponential worst-time complexity. We then exhibit a heuristic, which can be seen as a greedy approach classically used for the supertree problems, that consists in constructing progressively the tree from its root to its leaves. The main module of this heuristic is to infer the minimum number of duplications preceding the first speciation, which we call the Minimum pre-Speciation Duplication problem. We show that the supergenetree problem for the duplication cost, and even its restricted version the Minimum pre-Speciation Duplication problem, are NP-hard to approximate within a n^1-ϵ factor, for any 0 < ϵ < 1 (n being the number of genes). Moreover, these inapproximability results even hold for instances in which there is only one gene per species in the input trees. Finally we consider the supergenetree problem with restrictions on input trees that are relevant to many biological applications. Namely, we require each gene to appear in at most one tree, and genes of any tree to be related through orthology only. This is for example the case of gene trees obtained for OrthoMCL clusters called orthogroups [18]. We show that even for this restriction, the supergenetree problem remains NP-hard for the duplication cost.

The following section introduces preliminary notations that will be required in the rest of the paper.

The classical supertree problem is to state whether or not a set of partial trees are consistent, and if so construct a tree containing them all. Here, we introduce the classical methods for solving this problem, and explore natural generalizations to the supergenetree problem.

Let Γ be a set of n taxa (usually species in case of the supertree problem, and genes in case of the supergenetree problem), Γ_{i, 1 ≤ i ≤k}be a set of possibly overlapping subsets of Γ, and $\mathcal{G}=\left\{G_1,G_2,\cdots ,G_k\right\}$ be a set of trees where, for each 1 ≤ i ≤ k, G _i is a tree for Γ _i . Let $tr\left(\mathcal{G}\right)$ be the set of triplets of $\mathcal{G}$ defined as $tr\left(\mathcal{G}\right)=\left\{xy|z:\exists 1\le i\le k\mathsf{\text{such}}\mathsf{\text{that}}{G}_i{|}_{\left\{x,y,z\right\}}=xy|z\right\}$. Let $\mathcal{T}\left(\Gamma ,E\right)$ be the triplet graph with the set of vertices Γ and the set of edges E = {xy : ∃ z ∈ Γ such that $xy|z\in tr\left(\mathcal{G}\right)$} (see Figure 2 for an example).

The classical BUILD algorithm [1] determines, in polynomial time, whether a set of triplets is consistent and if so constructs a tree T, possibly non-binary, compatible with them. The algorithm takes as input the graph $\mathcal{T}=\mathcal{T}\left(\Gamma ,E\right)$. Let $\mathcal{C}\left(\mathcal{T}\right)=\left\{C_1,\cdots ,C_m\right\}$ be the set of connected components of $\mathcal{T}$. If $\mathcal{T}$ has at least three vertices and $\left|\mathcal{C}\left(\mathcal{T}\right)\right|=1$, then $\mathcal{G}$ is inconsistent, and the algorithm terminates. For example, the set of five gene trees of Figure 2 is inconsistent, as the corresponding triplet graph (including dotted lines) is connected. Otherwise, if $\left|V\left(\mathcal{T}\right)\right|\ge 3$, a polytomy is created over $\mathcal{C}\left(\mathcal{T}\right)$, the internal node of the polytomy being the root r(T) of the compatible tree T under construction and its children being m subtrees with leafsets V(C₁),..., V(C _m ), with their topology yet to be determined (where V(C _i ) ⊆ Γ denotes the set of taxa appearing in C _i ). The algorithm then recurses into each connected component, i.e. the subtree for V(C _i ) is determined recursively from the graph $\mathcal{T}\left(V\left(C_i\right),E{|}_{C_i}\right)$ defined by E| C _i = {xy : ∃ z ∈ Γ such that $xy|z\in tr\left(\mathcal{G}{|}_{V\left(C_i\right)}\right)$}. If, at any step, the considered graph has a single component containing more than two vertices, then $\mathcal{G}$ is reported as an inconsistent set of trees and the algorithm terminates. Otherwise, recursion terminates when the graph has at most two vertices, eventually returning a supertree T. See Figure 3 for an example.

The BUILD algorithm has been generalized in an algorithm called AllTrees [20] to output all supertrees compatible with a set of triplets in case consistency holds. Instead of taking each element of $\mathcal{C}\left(\mathcal{T}\right)$ as a separate leaf of r(T), all possible groupings, in other words all partitions of $\mathcal{C}\left(\mathcal{T}\right)$, are considered (see Figure 3, right, for a choice of bipartitions). For each partition $\mathcal{P}\left(\mathcal{C}\left(\mathcal{T}\right)\right)$ of $\mathcal{C}\left(\mathcal{T}\right)$, a polytomy is created over $\mathcal{P}\left(\mathcal{C}\left(\mathcal{T}\right)\right)$. The algorithm then iterates by considering each possible partition of each subgraph induced by each element of $\mathcal{P}\left(\mathcal{C}\left(\mathcal{T}\right)\right)$. The algorithm is polynomial in the size of the output that may be exponential in the size of the input.

A tree T compatible with $\mathcal{G}$ such that no internal edge of T can be contracted so that the resulting tree is also compatible with $\mathcal{G}$ is called a minimally resolved supertree. Minimally resolved supertrees contain all the information about all supertrees compatible with $\mathcal{G}$ but in a "compressed" format. By exhibiting some properties on graph components, Semple shows in [27] how some partitions of the triplet graph components can be avoided without loss of generality. The new developed algorithm, named AllMinTrees [27], outputs a minimally resolved tree in polynomial time. However, it was shown in [15] that the cardinality of the solution space can be exponential in n = |Γ|, leading to an exponential time algorithm with $\Omega \left({\frac{n}{2}}^{\frac{n}{2}}\right)$.

Notice that, in general, the trees output by all these methods are non-binary trees.

A greedy heuristic for the duplication cost

Instead of trying all partitions of the triplet graph components set at each step of the AllTrees or AllMinTrees algorithms, if the goal is to minimize the duplication cost, then a natural greedy approach would be to choose the best partition at each iteration, namely the one allowing to minimize the number of duplications preceding each speciation event. Such an approach would result in pushing duplications down the tree. It leads to the following restricted version of the supergenetree problem.

MINIMUM PRE-SPECIATION DUPLICATION PROBLEM (MINPRESPEDUP PROBLEM):

Input: A species set Σ and a binary species tree S for Σ; a gene family Γ, a set Γ_i,1≤i≤kof subsets of Γ, and a set $\mathcal{G}=\left\{G_1,G_2,\cdots ,G_k\right\}$ of consistent gene trees where, for each 1 ≤ i ≤ k, G _i is a tree on Γ _i .

Output: Among all gene trees for Γ compatible with $\mathcal{G}$, one tree T with minimum pre-speciation duplication nodes.

We will show in the following section that even this restricted version of the supergenetree problem is hard. Here, we give the intuition of a natural way of solving this problem, that reduces to repeated applications of the Max-Cut problem. Although known to be NP-hard, efficient heuristics exist (up to a factor of 0.878 [12]), that can be used for our purpose.

For the supertree problem, the triplet graph $\mathcal{T}=\mathcal{T}\left(\Gamma ,E\right)$ represents all triplets of the input trees that have to be combined. In the case of the supergenetree problem, another tree is available, the species tree S. A triplet xy|z found in the input trees $\mathcal{G}$ can be reconciled with S, and if r(xy|z) is a duplication, then any tree compatible with G must contain this duplication. Say that r(xy|z) is a required duplication mapped to r(S) if s(r(xy|z)) = r(S) and r(xy|z) is a duplication. Let us include this information in $\mathcal{T}$. More precisely, let $\mathcal{C}=\mathcal{C}\left(\mathcal{T}\right)$ denote the set of connected components of $\mathcal{T}$, and let $\mathcal{T}\left(\mathcal{C}\right)$ be the graph whose vertex set is $\mathcal{C}$, and $C_1,C_2\in \mathcal{C}$ share an edge if C₁ has vertices x, y and C₂ has a vertex z such that xy|z is a triplet in $\mathcal{G}$ with r(xy|z) being a required duplication mapped to r(S). If there are, say, d distinct such triplets, one can possibly set a weight of d to the C₁C₂ edge. See Figure 4 for an example.

Consider the problem of clustering the components of $\mathcal{T}\left(\mathcal{C}\right)$ into two parts B₁, B₂ of a bipartition in a way minimizing the number of duplications preceding the speciation event r(S). For each C₁ ∈ B₁ and C₂ ∈ B₂ such that C₁C₂ is an edge of $\mathcal{T}\left(\mathcal{C}\right)$, a tree T rooted at the bipartition (B₁, B₂) contains the required duplications mapped to r(S) represented by the C₁C₂ edge. If there are k such edges between B₁ and B₂ totalizing a weight of w, the single duplication at the root of T contains those w required duplications. In other words, we have "merged" w required duplications into one. It then becomes natural to find the bipartition of $\mathcal{T}\left(\mathcal{C}\right)$ that merges a maximum of duplications, i.e. that contains a set of edges crossing between the two parts of maximum weight. This is the well-known Max-Cut problem. For instance in Figure 4, the Max-Cut has a weight of 3 and leads to the optimal tree T₁. Any other bipartition sends a required duplication to a lower level and is hence suboptimal. The T₂ tree is obtained from first taking the suboptimal ({a₁, b₁, d₁}, {c₁, e₁, f₁}) bipartition, which creates a duplication at the root and defers the c₁e₁|f₁ required duplication for later.

Note however that the components of $\mathcal{T}$ may contain required duplications themselves, which are not represented by the edges of $\mathcal{T}\left(\mathcal{C}\right)$. Thus, a Max-Cut must then be applied recursively on both parts of the chosen bipartition. Therefore, this method does not benefit directly from the efficient approximation factor known for the Max-Cut problem, as the approximation error stacks with each application. In the next section, we show that, unlike Max-Cut, the MinPreSpeDup problem cannot admit a constant factor approximation (unless P = NP).

Through the rest of this section, we denote by n = |Γ| the size of the considered gene family. We show that both the MinDupSGT problem and its restriction the MinPreSpeDupSGT problem are NP-hard.

Theorem 1 The MinDupSGT and MinPreSpeDupSGT problems are both NP-hard to approximate within a factor of n^1-ϵ for any constant 0 < ϵ < 1. Moreover, this result holds for both problems even when restricted to instances having at most one gene per species in Γ.

Proof We use a reduction from the minimum k-colorability problem. Recall that a graph H = (V, E) is k-colorable if there is a partition {V₁, V₂,..., V _k } of V into independent sets (i.e. if x, y ∈ V _i for some 1 ≤ i ≤ k, then xy ∉ E). It is now well-known [33] that the smallest k for which H is k-colorable cannot be approximated within a factor of |V|^1-ϵ unless P = NP.

Now, given a graph H = (V, E), we construct a gene set Γ, a set of rooted triplet gene trees $\mathcal{G}$ and a species tree S such that H is k-colorable if and only if $\mathcal{G}$ is compatible with some gene tree T having at most k − 1 duplications when reconciled with S. Using the same construction, we also show that H is k-colorable if and only if $\mathcal{G}$ is compatible with some gene tree T having at most k − 1 pre-speciation duplications when reconciled with S. In both cases, the gene-species mapping s is bijective, proving the second part of the theorem statement.

Let Γ = {v₁, v₂ : v ∈ V} and for each edge vw ∈ E, add the triplets v₁v₂|w₁, v₁v₂|w₂, w₁w₂|v₁ and w₁w₂|v₂ to $\mathcal{G}$. Observe that this forces any tree T that displays $\mathcal{G}$ to display the tree ((v₁, v₂), (w₁, w₂)). Add one species to Σ for each gene of Γ so that the gene-species mapping s is bijective. As for S, first let S₁ be any binary tree with one leaf for each member of {s(v₁) : v ∈ V}, and in the same manner let S₂ be any binary tree with one leaf for each member of {s(v₂) : v ∈ V}. Obtain S by connecting the root of S₁ and the root of S₂ under a common parent r(S). Thus s(v₁) and s(v₂) are separated by r(S) for any v ∈ V. Clearly, $\mathcal{G}$ and S can be constructed in polynomial time.

Claim 1 : if H is k-colorable, then we can find a tree T compatible with $\mathcal{G}$ having at most k − 1 duplications. Moreover each such duplication x is a pre-speciation duplication (i.e. s(x) = r(S)).

Let {V₁, V₂,..., V _k } be a k-coloring of H. For each 1 ≤ i ≤ k, let T _i be the tree with leafset $V_i^{\prime }=\left\{v_1,v_2:v\in V_i\right\}$ that has only speciations, i.e. T _i is $S{|}_{s\left(V_i^{\prime }\right)}$ (because all genes in V' _i belong to a different species). Notice that s(r(T _i )) = r(S), since r(S) separates v₁ from v₂ for all v ∈ V. Obtain T by taking any binary tree on k leaves (and hence k − 1 internal nodes), then replacing each leaf by a distinct T _i . In this manner, T has k − 1 duplications since only the internal nodes of T that do not belong to any T _i need to be duplications. Moreover, each duplication node x has s(x) = r(S). It remains to show that T is compatible with $\mathcal{G}$. It suffices to observe that all triplets of $\mathcal{G}$ are of the form v₁v₂|w _h with h ∈ {1, 2}, and that such a triplet being in $\mathcal{G}$ implies that vw ∈ E. For such a triplet, we must then have v ∈ V _i and w ∈ V _j with i ≠ j, implying $v_1,v_2\in V_i^{\prime }$ and $w_h\in V_j^{\prime }$. By the construction of T, v₁v₂|w _h must be a triplet of T, as desired.

Claim 2 : if there is a tree T compatible with $\mathcal{G}$ having k − 1 duplications, then H is k-colorable. Moreover if T has k −1 duplications such that each duplication x has s(x) = r(S), then H is k-colorable.

Let T be a tree compatible with $\mathcal{G}$ having k − 1 duplications. Call a node x of T S-maximal if x is not a duplication node mapped to r(S) but every proper ancestor of x is a duplication mapped to r(S). Let X = {x₁, x₂,..., x _m } be the set of S-maximal nodes of T. Note that if y ≠ r(T) is a duplication mapped to r(S), then so is the parent of y. This implies that every leaf ℓ of T has at least one ancestor x _i in X, since x _i is the highest (i.e. closest to the root) ancestor of ℓ that is not a duplication mapped to r(S) (such an x _i always exists, since ℓ is itself one such node). Moreover, x _i is unique, as no other x _j ∈ X can be the ancestor of x _i . Therefore, $\left\{\mathcal{L}\left(T_{x_1}\right),\cdots ,\mathcal{L}\left(T_{x_m}\right)\right\}$ is a partition of $\mathcal{L}\left(T\right)$. We next show that m ≤ k. Let T' be the tree obtained by removing all descendants of x _i in T, for all 1 ≤ i ≤ m. Then T' is a binary tree with m leaves, and all its m − 1 internal nodes are duplications mapped to r(S). Since T has no more than k − 1 duplications (in either cases of the claim), T' has at most k − 1 internal nodes and therefore at most k leaves. We deduce that m ≤ k.

Observe that if vw ∈ E, then α = lca(v₁, v₂, w₁, w₂) must be a duplication such that s(α) = r(S). Indeed, α separates lca(v₁, v₂) from lca(w₁, w₂) since T displays ((v₁, v₂), (w₁, w₂)). But since s(lca(v₁, v₂)) = s(lca(w₁, w₂)) = r(S) by the construction of S, s(α) can only be r(S) as well, and so α must be a duplication.

Now, let V _i = {v : v₁ is a descendant of x _i } for each 1 ≤ i ≤ m. Take v, w ∈ V _i for some i. We show that vw ∉ E, and thus that {V₁,..., V _m } forms a coloring of H with at most k colors. The argument applies whether each duplication maps to r(S) or not, proving both parts of the claim. Suppose for the sake of contradiction that vw ∈ E, but v, w ∈ V _i . In T, lca(v₁, w₁) must be a descendant of x _i , since x _i is a common ancestor of v₁ and w₁ by the definition of V _i . Moreover, lca(v₁, w₁) ≠ x _i since lca(v₁, w₁) = lca(v₁, v₂, w₁, w₂) is a duplication mapped to r(S), as shown above, while x _i is not such a duplication, by its definition. Therefore, lca(v₁, w₁) is a proper descendant of x _i . But s(lca(v₁, w₁)) = r(S) = s(x _i ) implies that x _i is a duplication mapped to r(S), a contradiction. We conclude that {V₁,..., V _m } with m ≤ k is a proper coloring of H.

This reduction, together with the fact that the k-coloring problem is NP-hard to approximate within a n^1-ϵ factor, proves the Theorem.   □

We now consider the MinDupSGT problem in the special case where the input gene trees are independent speciation trees, meaning: (1) each gene of Γ appears in at most one gene tree leafset, and (2) gene trees of $\mathcal{G}=\left\{G_1,G_2,\cdots ,G_k\right\}$ are all speciation trees with respect to the species tree S. Our objective is to find a gene tree T compatible with $\mathcal{G}$ minimizing duplications that also maintains the orthology relationships specified by $\mathcal{G}$. In other words, we require that for every $G_i\in \mathcal{G},T{|}_{\mathcal{L}\left(G_i\right)}$ has only speciations. We say that a gene tree T that satisfies this property preserves the speciations of $\mathcal{G}$. Note that if T preserves the speciations of $\mathcal{G}$, then it is necessarily compatible with $\mathcal{G}$. We call $T{|}_{\mathcal{L}\left(G_i\right)}$ the copy of G _i in T.

MINIMUM SPECIATION SUPERGENETREE (MINSPECSGT PROBLEM):

Input: A species set Σ and a binary species tree S for Σ; a gene family Γ, a set Γ_i,1≤i≤kof disjoint subsets of Γ, and a set $\mathcal{G}=\left\{G_1,G_2,\cdots ,G_k\right\}$ of consistent independent speciation trees such that, for each 1 ≤ i ≤ k, G _i is a tree for Γ _i .

Output: Among all gene trees for Γ that preserve the speciations of $\mathcal{G}$, one tree T of minimum duplication cost.

Notice that, since no gene of Γ appears more than once in the set of input trees, $\mathcal{G}$ always admits a solution. Indeed, taking any binary tree on k leaves and replacing each leaf by a distinct G _i achieves the desired result. However, while apparently easier, we show that finding such a gene tree T minimizing the number of duplications is still hard.

Theorem 2 The decision version of the MinSpecSGT problem is NP-Complete, i.e. it is NP-Complete to decide if a species tree S and a set of independent speciation trees G admit a supertree T that preserves its speciations with at most k duplications.

Proof The problem is easily seen to be in NP, as it is easy to verify in polynomial time that a given gene tree T is compatible with $\mathcal{G}$, preserves its speciations and has k duplications. For NP-hardness, we turn to the decision version of the k-colorability problem. That is, for a given k, deciding if a graph H = (V, E) is k-colorable is NP-hard. We create from H a species tree S and a set of independent speciation trees $\mathcal{G}$ such that H is k-colorable if and only if S and G admit a supertree T with at most k − 1 duplications.

Let n = |V|, and denote V = {v₁,..., v _n }. To create S, start with any binary tree S' on $\left(\begin{array}{c}\hfill n\hfill \\ \hfill 2\hfill \end{array}\right)$ leaves. denote this leafset W = {w _i,j : 1 ≤ i <j ≤ n} so that there is a one-to-one correspondence between W and the unordered pairs of V. Then, add a special leaf a by joining it with the root of S' under a common parent p, and finally obtain S by adding another special leaf b by joining it with p under a common parent. Therefore, the species set is $\sum =\mathcal{L}\left(S\right)=W\cup \left\{a,b\right\}$.

For the construction of each gene tree $G\in \mathcal{G}$, we ease up notation by labeling each leaf g of G by s(g) directly (e.g. if we say that G is of the form (a, b), we mean that $\mathcal{G}$ has two leaves g _a , g _b such that s(g _a ) = a and s(g _b ) = b). In this manner, since all trees of $\mathcal{G}$ contain only speciations, each tree $G\in \mathcal{G}$ must be a subtree of S (or it is obtained from such a subtree by contracting edges). Also recall that we are assuming that each gene appears in at most one gene tree of $\mathcal{G}$, and so the genes from two distinct trees must also be distinct (even if they share the same label).

In $\mathcal{G}$, we first add k trees of the form (a, b), plus one tree G _i for each vertex v _i in H. The tree G _i corresponding to v _i ∈ V is a copy of S from which we remove every leaf except those w _j,k for which one of j = i or k = i holds, and (v _j v _k) ∈ E (i.e. we keep the leaves of W that correspond to an edge incident to v _i ). Also contract the degree 2 nodes of G _i . Notice that if v _i v _j ∈ E and i <j, then both G _i and G _j contain a gene in the w _i,j species. Also, if v _i v _j ∉E then G _i and G _j have no genes from a common species.

Claim 1 : if H is k-colorable, then S and $\mathcal{G}$ admit a supertree T having at most k − 1 duplications.

Let {V₁,..., V _k } be a k-partition of V into independent sets. Take any h such that 1 ≤ h ≤ k. Recall that if v _i , v _j ∈ V _h , then G _i and G _j share no gene from a common species (since v _i v _j ∉ E). Thus the trees in ${\mathcal{G}}_h=\{G_i:v_i\in V_h\}$ are all disjoint in terms of species. Let Σ _h be the set of species that appear in some tree of ${\mathcal{G}}_h$. Then, the tree $S{|}_{{\Sigma }_h}$ contains a copy of each tree in ${\mathcal{G}}_h$, and none of these copies overlap. Obtain T _h by joining a gene labeled a to r($S{|}_{{\Sigma }_h}$) under a common parent p, then joining a gene labeled b to p under a new common parent. Now, T _h contains a copy of each tree in G _h and a copy of one of the (a, b) trees. By taking a tree with k leaves (where at worst, each k − 1 internal node is a duplication), and replacing each leaf by the speciation trees T₁,..., T _k , we obtain a gene supertree T, which preserves the speciations of $\mathcal{G}$ and has at most k − 1 duplications.

Claim 2 : if S and $\mathcal{G}$ admit a supertree T having k − 1 duplications, then H is k-colorable.

We first show that if T has k − 1 duplications, then it must have exactly k speciations mapped to r(S). It cannot have more, as there would then be more than k − 1 duplications. Suppose instead that there are k' <k such speciations, and denote them x₁,...,x _k' . Note that there must be at least k' − 1 duplications in the ancestors of the x _i s. Now, for 1 ≤ i ≤ k', $T_{x_i}$ must contain a certain number of copies of a and b. Let m _i (a) and m _i (b) denote, respectively, the number of copies of a and b contained in $T_{x_i}$, noting that in total, there are k copies of each since there are k subtrees of the form (a, b) in $\mathcal{G}$. Since x _i is a speciation mapped to r(S), it separates the a copies from the b copies, thus the $T_{x_i}$ subtree must contain at least m _i (a) − 1 + m _i (b) − 1 duplications. Denote by d(T) the number of duplications in T. It follows that $\begin{array}{c}d\left(T\right)\ge k^{\prime }-1+{\sum }_{i=1}^{k^{\prime }}\left(m_i\left(a\right)+m_i\left(b\right)-2\right)=k^{\prime }-1-2k^{\prime }+{\sum }_{i=1}^{k^{\prime }}{m}_i\left(a\right)+{\sum }_{i=1}^{k^{\prime }}(m_i\left(b\right)\hfill \\ =-k^{\prime }-1+k+k=2k-k\prime -1>k-1\hfill \end{array}$ when k' <k, a contradiction.

Now, we can let x₁,..., x _k be the k speciation nodes of T mapped to r(S). The k − 1 duplications of T must then all be ancestors of the x _i , and they are all mapped to r(S). Therefore the $T_{x_1},\mathrm{...},T_{x_h}$ subtrees each contain only speciations. For any $G_i\in \mathcal{G}$ corresponding to v _i , one of the $T_{x_h}$ must contain the copy of G _i (for otherwise, the root of the copy of G _i in T would be a duplication, while it should be a speciation). Take any h such that 1 ≤ h ≤ k. We claim that V _h = {v _i : $T_{x_h}$ contains the copy of G _i } forms an inpedendent set. Since $T_{x_h}$ contains only speciations, it cannot contain genes from the same species. Thus for any G _i , G _j contained in $T_{x_h}$ we must have v _i v _j ∉ E, as otherwise G _i and G _j would share a gene from the same species. Therefore V _h is an independent set. Thus {V₁,..., V _k } form a k-coloring of H, and the proof is completed.   □

It is interesting to note that this does not show the NP-hardness of the special case in which the input trees are only triplets. Indeed, a tree G _i created in this reduction has as many leaves as the number of neighbors of its corresponding vertex v _i . Therefore, if H is a cubic graph (ie. 3-regular), one can generate an input with only triplets. However, deciding if a cubic graph is k-colorable can be done in linear time, and thus the triplets case cannot be shown NP-hard through this reduction. The 3-colorability problem is NP-hard on 4-regular graph though, showing the NP-hardness of the problem on input trees having at most 4 leaves.

We introduce the supergenetree problem which aims at constructing a supertree that displays a set of input gene trees while minimizing the reconciliation cost with respect to an input species tree. This problem is a natural formulation of the question of combining a set of gene trees obtained for subsets of a gene family into a full gene tree for the whole gene family.

The supergenetree problem is an extension of the classical supertree problem on a set of input leaf-labeled trees, where the input trees are gene trees and a species tree is used in order to evaluate the reconciliation/duplication cost of a supergenetree. We show how existing exact and greedy heuristic algorithms for the supertree problem can be used to devise approaches for solving the supergenetree problem. The resulting approaches have exponential worst-time complexity as the original supertree algorithms.

We show that the supergenetree problem for the duplication cost is NP-hard to approximate within a factor essentially better than n, and this complexity remains the same even when the problem is restricted, in a greedy approach, to finding a supertree with a minimum number of duplications before each speciation of the species tree. We also consider a restriction of the supergenetree problem relevant to many biological applications where subsets of orthologs are studied separately and then amalgamated into a single tree. Even this restriction is shown to be NP- Complete. The reconciliation cost remains to be studied, although we conjecture all of the above mentioned problems are hard in this case also.

These negative complexity results are not surprising though as they extend an already large set of problems related to supertrees that are known to be NP-hard. We think that appropriate heuristics for various classes of input trees are worth to be considered in future projects. Removing the assumption that the input gene trees are compatible would also lead to new interesting problems. A promising avenue would be to consider constructive FPT algorithms that can be integrated in greedy heuristics or dynamic programming algorithms. Also other restrictions on the input gene trees can be explored, hopefully leading to polynomial problems. Constructing gene trees by amalgamating smaller trees for subsets of orthologous genes is a natural way of constructing large trees that would benefit from a thorough theoretical and algorithmic analysis.