Abstract
Reconciling gene trees with a species tree is a fundamental problem to understand the evolution of gene families. Many existing approaches reconcile each gene tree independently. However, it is well-known that the evolution of gene families is interconnected. In this paper, we extend a previous approach to reconcile a set of gene trees with a species tree based on segmental macro-evolutionary events, where segmental duplication events and losses are associated with cost and , respectively. We show that the problem is polynomial-time solvable when (via LCA-mapping), while if the problem is NP-hard, even when and a single gene tree is given, solving a long standing open problem on the complexity of multi-gene reconciliation. On the positive side, we give a fixed-parameter algorithm for the problem, where the parameters are and the number d of segmental duplications, of time complexity . Finally, we demonstrate the usefulness of this algorithm on two previously studied real datasets: we first show that our method can be used to confirm or raise doubt on hypothetical segmental duplications on a set of 16 eukaryotes, then show how we can detect whole genome duplications in yeast genomes.
Keywords: Phylogenetics, Gene trees, Species trees, Reconciliation, Segmental duplications, Fixed-parameter tractability, NP-hardness, Whole genome duplications
Introduction
It is nowadays well established that the evolution of a gene family can differ from that of the species containing these genes. This can be due to quite a number of different reasons, including gene duplication, gene loss, horizontal gene transfer or incomplete lineage sorting, to only name a few [22]. While this discongruity between the gene phylogenies (the gene trees) and the species phylogeny (the species tree) complicates the process of reconstructing the latter from the former , every cloud has a silver lining: “plunging” gene trees into the species tree and analyzing the differences between these topologies, one can infer the macro-evolutionary events that shaped gene evolution. This is the rationale behind the species tree-gene tree reconciliation, a concept introduced in [13] and first formally defined in [24]. Understanding these macro-evolutionary events allows us to better understand the mechanisms of evolution with applications ranging from orthology detection [9, 18, 19, 30] to ancestral genome reconstruction [11], and recently in dating phylogenies [5, 7].
It is well-known that the evolution of gene families is interconnected. However, in current pipelines, each gene tree is reconciled independently with the species tree, even when posterior to the reconciliation phase the genes are considered as related, e.g. [11]. A more pertinent approach would be to reconcile the set of gene trees at once and consider segmental macro-evolutionary events, i.e. events that concern a chromosome segment instead of a single gene.
Some work has been done in the past to model segmental gene duplications and three models have been considered: the ec (Episode Clustering) problem, the me (Minimum Episodes) problem [1, 14], and the mgd (Multiple Gene Duplication) problem [12]. The ec and mgd problems both aim at clustering duplications together by minimizing the number of locations in the species tree where at least one duplication occurred, with the additional requirement that a cluster cannot contain two gene duplications from a same gene tree in the mgd problem. The me problem is more biologically-relevant, because it aims at minimizing the actual number of segmental duplications (more details in "Reconciliation with segmental duplications" section). Most of the exact solutions proposed for the me problem [1, 20, 26] deal with a constrained version, since the possible mappings of a gene tree node are limited to given intervals, see for example [1, Def. 2.4]. In [26], a simple time algorithm is presented for the unconstrained version (here hides polynomial factors), where k is the number of speciation nodes that have descending duplications under the LCA-mapping. This shows that the problem is fixed-parameter tractable (FPT) in k. But since the LCA-mapping maximizes the number of speciation nodes, there is no reason to believe that k is a small parameter, and so more practical FPT algorithms are needed. Recently, Delabre et al. [8] studied the problem of reconstructing the evolution of syntenic blocks. Their model allows segmental duplications, but is more constrained since it requires every gene family of every block to have evolved along the same tree.
In this paper, we extend the unconstrained ME model to gene losses and provide a variety of new algorithmic results. We allow weighing segmental duplication events and loss events by separate costs and , respectively. We show that if , then an optimal reconciliation can be obtained by reconciling each gene tree separately under the usual LCA-mapping, even in the context of segmental duplications. On the other hand, we show that if and both costs are given, reconciling a set of gene trees while minimizing segmental gene duplications and gene losses is NP-hard. The hardness also holds in the particular case that we ignore losses, i.e. when . This solves a long standing open question on the complexity of the reconciliation problem under this model (in [1], the authors already said “it would be interesting to extend the [...] model of Guigó et al. (1996) by relaxing the constraints on the possible locations of gene duplications on the species tree”. The question is stated as still open in [26]). The hardness holds also when only a single gene tree is given. On the positive side, we describe an algorithm that is practical when and are not too far apart. More precisely, we show that multi-gene tree reconciliation is fixed-parameter tractable in the ratio and the number d of segmental duplications, and can be solved in time . The algorithm has been implemented and tested and is freely available1 at https://github.com/AEVO-lab/MultRec. We first evaluate the potential of multi-gene reconciliation on a set of 16 eukaryotes, and show that our method can find scenarios with less duplications than other approaches. While some previously identified segmental duplications are confirmed by our results, it casts some doubt on others as they do not occur in our optimal scenarios. We then show how the algorithm can be used to detect whole genome duplications in yeast genomes. Further work includes incorporating in the model segmental gene losses and segmental horizontal gene transfers, with a similar flavor than the heuristic method discussed in [10].
Preliminaries
Basic notions
For our purposes, a rooted phylogenetic tree is an oriented tree, where V(T) is the set of nodes, E(T) is the set of arcs, all oriented away from r(T), the root. Unless stated otherwise, all trees in this paper are rooted phylogenetic trees. A forest is a directed graph in which every connected component is a tree. Denote by t(F) the set of trees of F that are formed by its connected components. Note that a tree is itself a forest. In what follows, we shall extend the usual terminology on trees to forests.
For an arc (x, y) of F, we call x the parent of y, and y a child of x. If there exists a path that starts at x and ends at y, then x is an ancestor of y and y is a descendant of x. We say y is a proper descendant of x if , and then x is a proper ancestor of y. This defines a partial order denoted by , and if (we may omit the F subscript if clear from the context). If none of and holds, then x and y are incomparable. The set of children of x is denoted ch(x) and its parent x is denoted par(x) [which is defined to be x if x itself is a root of a tree in t(F)]. For some integer , we define as the k-th parent of x. Formally, and for . The number of children |ch(x)| of x is called the out-degree of x. Nodes with no children are leaves, all others are internal nodes. The set of leaves of a tree F is denoted by L(F). The leaves of F are bijectively labeled by a set of labels. A forest is binary if for all internal nodes x. Given a set of nodes X that belong to the same tree , the lowest common ancestor of X, denoted , is the node z that satisfies for all and such that no child of z satisfies this property. We leave undefined if no such node exists (when elements of X belong to different trees of t(F)). We may write instead of . The height of a forest F, denoted h(F), is the number of nodes of a longest directed path from a root to a leaf in a tree of F (note that the height is sometimes defined as the number of arcs on such a path—here we use the number of nodes instead). Observe that since a tree is a forest, all the above notions also apply on trees.
Reconciliations
A reconciliation usually involves two rooted phylogenetic trees, a gene tree G and a species tree S, which we always assume to be both binary. In what follows, we will instead define reconciliation between a gene forest and a species tree. Here can be thought of as a set of gene trees. Each leaf of represents a distinct extant gene, and and S are related by a function , which means that each extant gene belongs to an extant species. Note that s does not have to be injective (in particular, several genes from a same gene tree G of can belong to the same species) or surjective (some species may not contain any gene of ). Given and S, we will implicitly assume the existence of the function s.
In a reconciliation, each node of is associated to a node of S and an event—a speciation (), a duplication () or a contemporary event ()—under some constraints. A contemporary event associates a leaf u of with a leaf x of S such that . A speciation in a node u of is constrained to the existence of two separated paths from the mapping of u to the mappings of its two children, while the only constraint given by a duplication event is that evolution of cannot go back in time. More formally:
Definition 1
(Reconciliation) Given a gene forest and a species tree S, a reconciliation between and S is a function that maps each node u of to a pair where is a node of V(S) and is an event of type or , such that:
if u is a leaf of , then and ;
- if u is an internal node of with children , then exactly one of following cases holds:
- , and are incomparable;
- , and
Note that if consists of one tree, this definition coincides with the usual one given in the literature (first formally defined in [24]). We say that is an LCA-mapping if, for each internal node with children , . Note that there may be more than one LCA-mapping, since the and events on internal nodes can vary. The number of duplications of , denoted by is the number of nodes u of such that . For counting the losses, first define for the distance dist(x, y) as the number of arcs on the path from x to y. Then, for every internal node u with children , the number of losses associated with u in a reconciliation , denoted by , is defined as follows:
if , then ;
if , then .
The number of losses of a reconciliation , denoted by , is the sum of for all internal nodes of . The usual cost of , denoted by , is [21], where and are respectively the cost of a duplication and a loss event (it is usually assumed that speciations do not incur cost). A most parsimonious reconciliation, or MPR, is a reconciliation of minimum cost. It is not hard to see that finding such an can be achieved by computing a MPR for each tree in separately. This MPR is the unique LCA-mapping in which whenever it is allowed according to Definition 1 [3].
Reconciliation with segmental duplications
Given a reconciliation for in S, and given , write and for the set of duplications of mapped to s. We define to be the subgraph of induced by the nodes in . Note that is a forest.
Here we want to tackle the problem of reconciling several gene trees at the same time and counting segmental duplications only once. Given a set of duplications nodes occurring in a given node s of the species tree, it is easy to see that the minimum number of segmental duplications associated with s is the minimal number of parts in a partition of in which each part does not contain comparable nodes. See Fig. 1(4) for an example. This number coincides [1] with , i.e. the height of the forest of the duplications in s. Now, denote . For instance in Fig. 1, under the mapping in (2), we have , because for and . But under the mapping in (3), , since and . Note that this does not consider losses though—the mapping has more losses than .
Fig. 1.
(1) A species tree S. (2) A gene forest with two gene trees reconciled under the MPR that we denote . The nodes are labeled by the same name of the species they are mapped to but in lowercase. Black squares indicate duplication nodes. Losses are not shown. (3) The same forest but with another reconciliation for the internal nodes. (4) The forest , along with a partition into (possible) segmental duplications
The cost of is . If and S are unambiguous, we may write . We have the following problem:
Problem 1
Most parsimonious reconciliation of a set of trees with segmental duplications (MPRST-SD)
Instance: a species tree S, a gene forest , costs for duplications and for losses.
Output: a reconciliation of in S such that is minimum.
Note that, when , coincides with the unconstrained ME score defined in [26] (where it is called ME under the FHS model).
Properties of multi-gene reconciliations
We finish this section with some additional terminology and general properties of multi-gene reconciliations that will be useful throughout the paper. The next basic result states that in a reconciliation , we should set the events of internal nodes to whenever it is allowed.
Lemma 1
Let be a reconciliation for in S, and let such that . Let be identical to , with the exception that , and suppose that satisfies the requirements of Definition 1. Then .
Proof
Observe that changing from to cannot increase . Moreover, as and are the same as in for the two children and of u, by definition of duplications and losses this decreases the number of losses by 2. Thus , and this inequality is strict when .
Since we are looking for a most parsimonious reconciliation, by Lemma 1 we may assume that for an internal node , whenever allowed, and otherwise. Therefore, is implicitly defined by the mapping. To alleviate notation, we will treat as simply as a mapping from to V(S) and thus write instead of . We will assume that the events can be deduced from this mapping by Lemma 1.
Therefore, treating as a mapping, we will say that is valid if for every , for all descendants of v. We denote by the mapping obtained from by remapping to , i.e. for every , and . Since we are assuming that and events can be deduced from , the LCA-mapping is now unique: we denote by the LCA-mapping, defined as if , and otherwise , where and are the children of v. Note that for any valid reconciliation , we have for all . We also have the following, which will be useful to establish our results.
Lemma 2
Let be a mapping from to S. If , then v is a node under .
Proof
Let and be the two children of v. If , then v must be a duplication, by the definition of events. The same holds if and are not incomparable. Thus assume and that and are incomparable. This implies that one of or is incomparable with , say w.l.o.g. But , implying that is also incomparable with , a contradiction to the definition of .
Lemma 3
Let be a mapping from to S, and let . Suppose that there is some proper descendant of v such that . Then v is a duplication under .
Proof
If , we get , and so . We must then have for every node on the path between and v. In particular, v has a child with and thus v is a duplication. If instead , then v is a duplication by Lemma 2.
The Shift-down lemma will prove very useful to argue that we should shift mappings of duplications down when possible, as it saves losses (see Fig. 2). For future reference, do note however that this may increase the height of some duplication forest .
Fig. 2.
The Shift-down lemma in action. Here , and from to , we remap v from t to s and save 2 losses—4 losses are saved below v and 2 are added above
Lemma 4
(Shift-down lemma) Let be a mapping from to S, let , let and be such that . Suppose that is a valid mapping. Then .
Proof
Let and be the children of v, and denote and . Moreover denote . Let P be the set of nodes that appear on the path between s and t, excluding s but including t (note that s is a proper descendant of t but an ancestor of both and , by the validity of ). For instance in Fig. 2, . Observe that . Under , there is a loss for each node of P on both the and branches. (noting that v is a duplication by Lemma 2). These 2k losses are not present under . On the other hand, there are at most k losses that are present under but not under , which consist of one loss for each node of P on the (par(v), v) branch (in the case that v is not the root of its tree—otherwise, no such loss occurs). This proves that .
A “proof-by-picture” of the above Lemma appears in Fig. 2. When shifting down the mapping of v, some losses that appear left and right of v get “combined” on the branch above it.
The computational complexity of the mprst-sd problem
We separate the study of the complexity of the mprst-sd problem into two subcases: when and when .
The case of
The following theorem states that, when , the MPR (ie the LCA-mapping) is a solution to the mprst-sd problem.
Theorem 1
Let and S be an instance of mprst-sd, and suppose that , Then the LCA-mapping is a reconciliation of minimum cost for and S. Moreover if , is the unique reconciliation of minimum cost.
Proof
Let be a mapping of into S of minimum cost. Let be a minimal node of with the property that (i.e. all proper descendants of v satisfy ). Note that v must exists since, for every leaf , we have . Because , it follows that . Denote and . Then there is some such that . Consider the mapping . This possibly increases the sum of duplications by 1, so that . But by the Shift-down lemma, . Thus we have at most one duplication but save at least one loss.
If , this contradicts the optimality of , implying that v cannot exist and thus that . This proves the uniqueness of in this case.
If , then . By applying the above transformation successively on the minimal nodes v that are not mapped to , we eventually reach the LCA-mapping with an equal or better cost than .
The case of
We show that, in contrast with the case, the mprst-sd problem is NP-hard when and the costs are given as part of the input. More specifically, we show that the problem is NP-hard when one only wants to minimize the sum of duplication heights, i.e. . Note that if but is small enough, the effect will be the same and the hardness result also holds—for instance, putting and say ensures that even if a maximum number of losses appears on every branch of , it does not even amount to the cost of one duplication.
We briefly outline the main ideas of the reduction. We start from the Vertex Cover problem, where we are given a graph G and must find a subset of vertices of minimum size such that each edge has at least one endpoint in . The species tree S and the forest are constructed so that, for each vertex , there is a gene tree in with a long path of duplications, all of which could either be mapped to a species called or another species . We make it so that mapping to introduces one more duplication than mapping to , hence we have to “pay” for each . On the other hand, we construct a tree in for each edge in such that if, in or , we chose to map to either or , then can “reuse” these or duplications with no extra cost. However if we did not choose either or , will introduce a large number of new duplications. We are therefore forced to pick a minimum number of ’s to “cover” all the trees.
The construction
We will first need particular trees as described by the following Lemma. These trees guarantee that a prescribed set of leaves L are at distance exactly k from the root, and any two of the leaves in L have their LCA at distance at least k / 2. Recall that for a tree T and , denotes the number of edges on the path between u and v in T (we write dist(u, v) for short). A caterpillar is a binary rooted tree in which each internal node has one child that is a leaf, with the exception of one internal node which has two such children.
Lemma 5
Let be an integer, and let L be a given set of at most k labels. Then there exists a rooted tree T with leaf set with such that for any , and for any two distinct , . Moreover, T can be constructed in polynomial time with respect to k.
Proof
Let p be the smallest integer such that . First consider a fully balanced binary tree T on leaves, so that each leaf is at distance p from the root. Then replace each leaf by the root of a caterpillar of height (hence in the caterpillars the longest root-to-leaf path has edges). The resulting tree is T. Choose k of these caterpillars, and in each of them, assign a distinct label of L to a deepest leaf (any of the two). Thus for each , and clearly T can be built in polynomial time. We also have for each distinct . As , we have . This implies for .
In the following, we will assume that and . We reduce the Vertex Cover problem to that of finding a mapping of minimum cost for given and S. Recall that in the decision version of Vertex Cover, we are given a graph and an integer and are asked if there exists a subset with such that every edge of E has at least one endpoint in . For such a given instance, denote and (so that and ). The ordering of the ’s and ’s can be arbitrary, but must remain fixed for the remainder of the construction.
Let , and observe in particular that . We construct a species tree S and a gene forest from G. The construction is relatively technical, but we will provide the main intuitions after having fully described it. For convenience, we will describe as a set of gene trees instead of a single graph. Figure 3 illustrates the constructed species tree and gene trees. The construction of S is as follows: start with S being a caterpillar on leaves. Let
be the path of this caterpillar consisting of the internal nodes, ordered by decreasing depth (i.e. is the deepest internal node, and is the root). For each , call and , respectively, the leaf child of and . Note that has two leaf children: choose one to name arbitrarily among the two. Then for each edge uv of S, graft a large (but polynomial) number, say , of leaves on the uv edge (grafting t leaves on an edge uv consists of subdividing uv t times, thereby creating t new internal nodes of degree 2, then adding a leaf child to each of these nodes, see Fig. 3). We will refer to these grafted leaves as the special uv leaves, and the parents of these leaves as the special uv nodes. These special nodes are the fundamental tool that lets us control the range of duplication mappings.
Fig. 3.
The species tree S, and the and trees. The internal nodes are labeled by their LCA-mapping , and black squares on the gene trees represent duplication nodes under
Finally, for each , replace the leaf by a tree that contains K distinguished leaves such that for all , and such that for all distinct . By Lemma 5, each can be constructed in polynomial time. Note that the edges inside a subtree do not have special leaves grafted onto them. This concludes the construction of S.
We proceed with the construction of the set of gene trees . Most of the trees of consist of a subset of the nodes of S, to which we graft additional leaves to introduce duplications—some terminology is needed before proceeding. For , deleting w consists in removing w and all its descendants from S, then contracting the possible resulting degree two vertex (which was the parent of w if ). If this leaves a root with only one child, we contract the root with its child. For , keeping X consists of successively deleting every node that has no descendant in X until none remains (the tree obtained by keeping X is sometimes called the restriction of S to X).
The forest is the union of three sets of trees A, B, C, so that . Roughly speaking A is a set of trees corresponding to the choice of vertices in a vertex cover, B is a set of trees to ensure that we “pay” a cost of one for each vertex in the cover, and C is a set of trees corresponding to edges. For simplicity, we shall describe the trees of as having leaves labeled by elements of —a leaf labeled in a gene tree is understood to be a unique gene that belongs to species s.
-
The A trees Let , one tree for each vertex of G. For each , obtain by first taking a copy of S, then deleting all the special leaves. Then on the resulting branch, graft 10K leaves labeled . Then delete the child of that is also an ancestor of (removing in the process). Figure 3 bottom-left might be helpful.
As a result, under the LCA-mapping , has a path of 10K duplications mapped to . One can choose whether to keep this mapping in , or to remap these duplications to .
The B trees Let . For , is obtained from S by deleting all except of the special leaves, and grafting a leaf labeled on the edge between and its parent, thereby creating a single duplication mapped to under .
- The C trees Let , where for , corresponds to edge . Let be the two endpoints of edge , where . To describe , we list the set of leaves that we keep from S. Keep all the leaves of the subtree of S, and keep a subset of the special leaves defined as follows:
- Keep 9K of the special leaves;
- Keep of the special leaves;
- Keep 9K of the special leaves;
-
Keep all the special leaves.No other leaves are kept. Next, in the tree obtained by keeping the aforementioned list of leaves, for each we graft, on the edge between and its parent, another leaf labeled . Thus has K duplications, all located at the bottom of the subtree. This concludes our construction.
Let us pause for a moment and provide a bit of intuition for this construction. We will show that G has a vertex cover of size if and only if there exists a mapping of of cost at most . As we will show later on, two trees cannot have a duplication mapped to the same species of S, so these trees alone account for 10Kn duplications. The duplications in the trees account for n more duplications, so that if we kept the LCA-mapping, we would have duplications. But some of these duplications could be remapped to , at the cost of creating a path of 10K duplications to . This is fine if also has a path of 10K duplications to , as this does not incur additional height. In this case, the pairs introduces 10K duplications. If instead this path in is mapped to , we will show that remapping is forbidden, summing up to duplications for such a particular pair. The disadvantage of remapping every to will become apparent when we consider the trees. The idea is that mapping the duplications of to represents including vertex in the vertex cover, and mapping them to represents not including . Because each time we map the duplications to , we have the additional duplication in , we cannot do that more than times.
Now consider a tree, . Under the LCA-mapping, the duplications at the bottom enforce an additional K duplications. This can be avoided by, say, mapping all these duplications to the same species. For instance, we could remap all these duplications to some species of S. But in this case, because of Lemma 3, every node v of above a duplication for which will become a duplication. This will create a duplication subtree D in with a large height, and our goal will be to “reuse” the duplications we chose in the and trees. As it turns out, this “reuse” of duplications will be feasible only if some or has duplication height 10K. If this does not occur, any attempt at mapping the nodes to a common species will induce a chain reaction of too many duplications created above.
The complete proof is somewhat technical. The interested reader can find it in Appendix.
Theorem 2
The mprst-sd problem is NP-hard for and for given .
The above hardness supposes that and can be arbitrarily far apart. This leaves open the question of whether MPRST-SD is NP-hard when and are fixed constants—in particular when and , where is some very small constant. We end this section by showing that the above hardness result persists event if only one gene tree is given. The idea is to reduce from the MPRST-SD shown hard just above. Given a species tree S and a gene forest , we make a single tree by incorporating a large number of speciations (under ) above the root of each tree of (modifying S accordingly), then successively joining the roots of two trees of under a common parent until has only one tree.
Theorem 3
The mprst-sd problem is NP-hard for and for given , even if only one gene tree is given as input.
Proof
We reduce from the mprst-sd problem in which multiple trees are given. We assume that and and only consider duplications—we use the same argument as before to justify that the problem is NP-hard for very small . Let S be the given species tree and be the given gene forest. As we are working with the decision version of mprst-sd, assume we are given an integer t and asked whether for some . Denote and let be the trees of . We construct a corresponding instance of a species tree and a single gene tree T as follows (the construction is illustrated in Fig. 4). Let be a species tree obtained by adding nodes “above” the root of S. More precisely, first let C be a caterpillar with internal nodes. Let l be a deepest leaf of C. Obtain by replacing l by the root of S. Then, obtain the gene tree T by taking k copies of C, and for each leaf of each other than l, put as the corresponding leaf in . Then for each , replace the l leaf of by the tree (we keep the leaf mapping s of ), resulting in a tree we call . Finally, let be a caterpillar with k leaves , and replace each by the tree. The resulting tree is T. We show that for some if and only if for some .
Fig. 4.
The construction of and T from S and the set of gene trees (here ). The black squares indicate the path of duplications that must be mapped to
Notice the following: in any mapping of T, the internal nodes of the caterpillar must be duplications mapped to , so that . Also note that under the LCA mapping for T and , the only duplications other than those mentioned above occur in the subtrees. The is then easy to see: given such that , we set for every node v of T that is also in (namely the nodes of ), and set for every other node. This achieves a cost of .
As for the direction, suppose that for some mapping . Observe that under the LCA-mapping in T, each root of each subtree has a path of speciations in its ancestors. If any node in a subtree of T is mapped to , then all these speciations become duplications (by Lemma 3), which would contradict . We may thus assume that no node belonging to a subtree is mapped to . Since , this implies that the restriction of to the subtrees has cost at most t.
More formally, consider the mapping from to in which we put for all . Then , because does not contain the top duplications of , and cannot introduce longer duplication paths than in .
We are not done, however, since is a mapping from to , and not from to S. Consider the set of nodes v of such that . We will remap every such node to r(S) and show that this cannot increase the cost. Observe that if , then every ancestor of v in is also in Q. Also, every node in Q is a duplication (by invoking Lemma 2).
Consider the mapping from to in which we put for all , and for all . It is not difficult to see that is valid.
Now, for all and for all . Moreover, the height of the r(S) duplications under cannot be more than the height of the forest induced by Q and the duplications mapped to r(S) under . In other words,
Therefore, the sum of duplication heights cannot have increased. Finally, because is a mapping from to S, we deduce that , as desired.
An FPT algorithm
In this section, we show that for costs and a parameter , if there is an optimal reconciliation of cost satisfying , then can be found in time .
In what follows, we allow mappings to be partially defined, and we use the symbol to indicate undetermined mappings. The idea is to start from a mapping in which every internal node is undetermined, and gradually determine those in a bottom-up fashion. We need an additional set of definitions. We will assume that (although the algorithm described in this section can solve the case by setting to a very small value).
We say that the mapping is a partial mapping if for every leaf , and it holds that whenever , we have for every descendant of v. That is, if a node is determined, then all its descendants also are. This also implies that every ancestor of a -node is also a -node. A node is a minimal -node (under ) if and for each child of v. If for every , then is called complete. Note that if is partial and , one can already determine whether v is an or a node, and hence we may say that v is a speciation or a duplication under . Also note that the definitions of and extend naturally to a partial mapping by considering the forest induced by the nodes not mapped to .
If is a partial mapping, we call a completion of if is complete, and whenever . Note that such a completion always exists, as in particular one can map every -node to the root of S (such a mapping must be valid, since all ancestors of a -node are also -nodes, which ensures that for every descendant of a newly mapped -node v). We say that is an optimal completion of if is minimum among every possible completion of . For a minimal -node v with children and , we denote , i.e. the lowest species of S to which v can possibly be mapped to in any completion of . Observe that . Moreover, if v is a minimal -node, then in any completion of , is a valid mapping. A minimal -node v is called a lowest minimal -node if, for every minimal -node w distinct from v, either or and are incomparable.
The following Lemma forms the basis of our FPT algorithm, as it allows us to bound the possible mappings of a minimal -node.
Lemma 6
Let be a partial mapping and let v be a minimal -node. Then for any optimal completion of , .
Proof
Let be an optimal completion of and let . Note that . Now suppose that . Then by the Shift-down lemma, . Thus . This contradicts the optimality of .
A node is a required duplication (under ) if, in any completion of , v is a duplication under . We first show that required duplications are easy to find.
Lemma 7
Let v be a minimal -node under , and let and be its two children. Then v is a required duplication under if and only if or .
Proof
Suppose that , and let be a completion of . If , then v is a duplication by definition. Otherwise, , and v is a duplication by Lemma 2. The case when is identical.
Conversely, suppose that and . Then and must be incomparable descendants of (because otherwise if e.g. , then we would have whereas we are assuming that ). Take any completion of such that . To see that v is a speciation under , it remains to argue that . Since is an ancestor of both and , we have . We also have , and equality follows.
Lemmas 8 and 9 allow us to find minimal -nodes of that are the easiest to deal with, as their mapping in an optimal completion can be determined with certainty.
Lemma 8
Let v be a minimal -node under . If v is not a required duplication under , then for any optimal completion of .
Proof
Let be the children of v, and let be an optimal completion of . Since v is not a required duplication, by Lemma 7 we have and and, as argued in the proof of Lemma 7, and are incomparable. We thus have that . Then is a valid mapping, and v is a speciation under this mapping. Hence . Then by the Shift-down lemma, this new mapping has fewer losses, and thus attains a lower cost than .
Lemma 9
Let v be a minimal -node under , and let . If , then for any optimal completion of .
Proof
Let be an optimal completion of . Denote , and assume that (as otherwise, we are done). Let . We have that by the Shift-down lemma. To prove the Lemma, we then show that . Suppose otherwise that . As only v changed mapping to s to go from to , this implies that because of v. Since under , no ancestor of v is mapped to s, it must be that under , v is the root of a subtree T of height of duplications in s. Since T contains only descendants of v, it must also be that (here is the mapping defined in the Lemma statement). As we are assuming that , we get . This is a contradiction, since (the left inequality because is a completion of , and the right equality by the choice of ). Then and contradicts the fact that is optimal.
We say that a minimal -node is easy (under if v falls into one of the cases described by Lemma 8 or Lemma 9. Formally, v is easy if either v is a speciation mapped to under any optimal completion of (Lemma 8), or (Lemma 9). Our strategy will be to “clean-up” the easy nodes, meaning that we map them to as prescribed above, and then handle the remaining non-easy nodes by branching over the possibilities. We say that a partial mapping is clean if every minimal -node v satisfies the two following conditions:
- [C1]
v is not easy;
- [C2]
for all duplication nodes w (under with ), either or is incomparable with .
Roughly speaking, C2 says that all further duplications that may “appear” in a completion of will be mapped to nodes “above” the current duplications in . The purpose of C2 is to allow us to create duplication nodes with mappings from the bottom of S to the top. Our goal will be to build our mapping in a bottom-up fashion in whilst maintaining this condition. The next lemma states that if is clean and some lowest minimal -node v gets mapped to species s, then v brings with it every minimal -node that can be mapped to s.
Lemma 10
Suppose that is a clean partial mapping, and let be an optimal completion of . Let v be a lowest minimal -node under , and let . Then for every minimal -node w such that , we have .
Proof
Denote . Suppose first that . Note that since is clean, v is not easy, which implies that . Since v is a lowest minimal -node, if w is a minimal -node such that , we must have , as otherwise v would not have the ‘lowest’ property. Moreover, because v and w are both minimal -nodes under the partial mapping , one cannot be the ancestor of the other and so v and w are incomparable. This implies that mapping w to s under cannot further increase (because we already increased it by 1 when mapping v to s). Thus , and w is easy under and must be mapped to s by Lemma 9. This proves the case.
Now assume that , and let w be a minimal -node with . Let us denote . If , then we are done. Suppose that , noting that (because w must be a duplication node, due to being clean). If , then w is also a lowest minimal -node. In this case, using the arguments from the previous paragraph and swapping the roles of v and w, one can see that v is easy in and must be mapped to , a contradiction. Thus assume . Under , for each child of v, we have , and for each ancestor of v, we have . Therefore, by remapping v to , v is the only duplication mapped to among its ancestors and descendants. In other words, because , we have . Moreover by the Shift-down lemma, , which contradicts the optimality of .
The remaining case is . Note that (because v must be a duplication node, due to being clean). Since it holds that v is a minimal -node, that is clean and that , it must be the case that has no duplication mapped to s (by the second property of cleanness). In particular, w has no descendant that is a duplication mapped to s under (and hence under ). Moreover, as , w has no ancestor that is a duplication mapped to s. Thus , and the Shift-down lemma contradicts the optimality of . This concludes the proof.
We are finally ready to describe our algorithm. We start from a partial mapping with for every internal node v of . We gradually “fill-up” the -nodes of in a bottom-up fashion, maintaining a clean mapping at each step and ensuring that each decision leads to an optimal completion . To do this, we pick a lowest minimal -node v, and “guess” among the possibilities. This increases some by 1. For each such guess s, we use Lemma 10 to map the appropriate minimal -nodes to s, then take care of the easy nodes to obtain another clean mapping. We repeat until we have either found a complete mapping or we have a duplication height higher than d. An illustration of a pass through the algorithm is shown in Fig. 5.
Fig. 5.
An illustration of one pass through the algorithm. The species tree S is left and has two trees (middle) and partial mapping (labels are the lowercase of the species). Here is in a clean state, and the algorithm will pick a lowest minimal -node (white circle) and try to map it to, say, H. The forest on the right is the state of after applying this and cleaning up
Notice that the algorithm assumes that it receives a clean partial mapping . In particular, the initial mapping that we pass to the first call should satisfy the two properties of cleanness. To achieve this, we start with a partial mapping in which every internal node is a -node. Then, while there is a minimal -node v that is not a required duplication, we set , which makes v a speciation. It is straightforward to see that the resulting is clean: C1 is satisfied because we cannot make any more minimal -nodes become speciations, and we cannot create any duplication node without increasing because has no duplication. C2 is met because there are no duplications at all.
The complexity follows from the fact that the algorithm creates a search tree of degree of depth at most d. The main technicality is to show that the algorithm maintains a clean mapping before each recursive call.2
Theorem 4
Algorithm 1 is correct and finds a minimum cost mapping satisfying , if any, in time .
Proof
We show by induction over the depth of the search tree that, in any recursive call made to Algorithm 1 with partial mapping , the algorithm returns the cost of an optimal completion of having , or if no such completion exists—assuming that the algorithm receives a clean mapping as input. Thus in order to use induction, we must also show that at each recursive call done on line 15, is a clean mapping. We additionally claim that the search tree created by the algorithm has depth at most d. To show this, we will also prove that every sent to a recursive call satisfies .
The base cases of lines 3–5 are trivial. For the induction step, let v be the lowest minimal -node chosen on line 7. By Lemma 6, if is an optimal completion of and , then . We try all the possibilities in the for-loop on line 9. The for-loop on line 11 is justified by Lemma 10, and the for-loop on line 13 is justified by Lemmas 8 and 9. Assuming that is clean on line 15, by induction the recursive call will return the cost of an optimal completion of having , if any such completion exists. It remains to argue that for every sent to a recursive call on line 15, is clean and .
Let us first show that such a is clean, for each choice of s on line 9. There clearly cannot be an easy node under after line 13, so we must show C2, i.e. that for any minimal -node w under , there is no duplication z under satisfying . Suppose instead that for some duplication node z. Let be a descendant of w that is a minimal -node in (note that is possible). We must have . By our assumption, we then have . Then z cannot be a duplication under , as otherwise itself could not be clean (by C2 applied on z and ). Thus z is a newly introduced duplication in , and so z was a -node under . Note that Algorithm 1 maps -nodes of one after another, in some order . Suppose without loss of generality that z is the first duplication node in this ordering that gets mapped to . There are two cases: either , or .
Suppose first that . Lines 10 and 11 can only map -nodes to s, and line 13 either maps speciation nodes, or easy nodes that become duplications. Thus when , we may assume that z falls into the latter case, i.e. z is easy before being mapped, so that mapping z to does not increase . Because z is the first -node that gets mapped to , this is only possible if there was already a duplication mapped to in . This implies that , and that was not clean (by C2 applied on and ). This is a contradiction.
We may thus assume that . This implies . If w was a minimal -node in , it would have been mapped to s on line 11, and so in this case w cannot also be a minimal -node in , as we supposed. If instead w was not a minimal -node in , then w has a descendant that was a minimal -node under . We have , which implies that gets mapped to s on line 11. This makes impossible, and we have reached a contradiction. We deduce that z cannot exist, and that is clean.
It remains to show that . Again, let s be the chosen species on line 9. Suppose first that . Then , as otherwise v would be easy under , contradicting its cleanness. In this situation, as argued in the proof of Lemma 10, each node w that gets mapped to s on line 11 or on line 13 is easy, and thus cannot further increase the height of the duplications in s. If , then , since by cleanness no duplication under maps to s. Here, each node w that gets mapped on line 11 has no descendant nor ancestor mapped to s, and thus the height does not increase. Noting that remapping easy nodes on line 13 cannot alter the duplication heights, we get in both cases that . This proves the correctness of the algorithm.
As for the complexity, the algorithm creates a search tree of degree and of depth at most d. Each pass can easily seen to be feasible in time (with appropriate pre-parsing to compute in constant time, and to decide if a node is easy or not in constant time as well), and so the total complexity is .
Experiments
We used our software to reanalyze a data set of 53 gene trees for 16 eukaryotes presented in [14] and already reanalyzed in [1, 25]. In [1], the authors showed that, if segmental duplications are not accounted for, we get a solution having equal to 9, while their software (ExactMGD) returns a solution with equal to 5. We were able to retrieve the solution with maximum height of 5 fixing and , but, as soon as , we got a solution with maximum height of 4 where no duplications are placed in the branch leading to the Tetrapoda clade. The result is shown in Fig. 6 (also see [25, Fig. 1]). In [14], the Tetrapoda duplication was only supported by 6 trees (11.3%), whereas in our solution all these duplications were remapped to the common ancestor of Chlorophyceae and Mammalia. The other locations of segmental duplications inferred in [14] are confirmed.3 This may sow some doubt on the actual existence of a segmental duplication in the LCA of the Tetrapoda clade.
Fig. 6.

The species tree phylogeny for the 16 eukaryotes studied by Guigó et al. Black nodes indicate the location of segmental duplications detected by our algorithm (the 2 black circles suggest two consecutive segmental duplications)
We also reanalyzed the data set of yeast species described in [2]. First, we selected from the data set the 2379 gene trees containing all 16 species and refined unsupported branches using the method described in [16] and implemented in ecceTERA [15] with a bootstrap threshold of 0.9 and . Using our method with , we were able to detect the ancient genome duplication in Saccharomyces cerevisiae already established using synteny information [17], with 216 gene families supporting the event. Other nodes with a signature of segmental duplication are nodes 7, 6, 13 and 2 (refer to Fig. 7) with respectively 190, 157, 148 and 136 gene families supporting the event. It would be interesting to see if the synteny information supports these hypotheses.
Fig. 7.

The species tree phylogeny for the yeast data set described in [2]. Numbers at the internal nodes are meaningless and are only used to refer to the nodes in the main text
Note on the costs: As for any other parsimony method, the costs associated to the events in Algorithm 1 (i.e. and ) have to be fixed by the user and cannot be estimated. Several possibilities exist to estimate these costs. A method for cost estimation for reconciliation, based on reducing large fluctuations in ancient genome sizes, has been proposed in [6]. Another possibility is to use costs estimated by a maximum likelihood method, as done in [23], where the costs estimated in [27, 28] were used. Uncertainty in the input costs can also be tackled by considering several cost vectors and pareto-optimal reconciliations, or even via sampling; examples of these approach can be found respectively in [29] in the context of reconciliations (i.e. reconciliations where horizontal gene transfers are also allowed) and in [4], where Boltzmann sampling is used in the context of evolution of gene adjacencies, a problem related to reconciliations.
Conclusion
We have presented an approach for the reconciliation of a set of gene trees and a species tree, based on segmental macro-evolutionary events, where segmental duplication events and losses are associated with cost and , respectively. We have shown that the problem is polynomial-time solvable when , since LCA-mapping is already an optimal solution. When the problem is NP-hard, even when and a single gene tree is given. This result solves a long standing open problem on the complexity of the reconciliation of a set of gene trees with a species tree. Moreover, we have given a fixed-parameter algorithm of time complexity , where d is the number of segmental duplications, that has been tested on real data, showing its effectiveness.
This work poses a variety of questions that deserve further investigation. The complexity of the problem when is a constant remains an open problem. Moreover, our FPT algorithm can handle data sets with a sum of duplication height of about , but in the future, one might consider whether there exist fast approximation algorithms for MPRST-SD in order to attain better scalability. Other future directions include a multivariate complexity analysis of the problem, in order to understand whether it is possible to identify other parameters that are small in practice. Finally, we plan to extend the experimental analysis to other data sets, for instance for the detection of whole genome duplications in plants.
Authors' contributions
RD, ML and CS all participated in writing the manuscript and establishing the theoretical results. ML implemented the algorithm, CS ran the experiments. All authors read and approved the final manuscript.
Acknowledgements
The authors would like to thank Mukul Bansal for providing the eukaryotes data set for the experiments section.
Competing interests
The authors declare that they have no competing interests.
Availability of data and materials
The implementation is available at https://github.com/AEVO-lab/MultRec. The data used in the experiments is available on demand.
Consent for publication
Not applicable.
Ethics approval and consent to participate
Not applicable.
Funding
The work of ML was supported by a postdoctoral fellowship from the Natural Sciences and Engineering Research Council (NSERC), Canada.
Publisher’s Note
Springer Nature remains neutral with regard to jurisdictional claims in published maps and institutional affiliations.
Appendix: Proof of Theorem 2
Fig. 8.
The species tree S, and the and trees. The internal nodes are labeled by their LCA-mapping , and black squares on the gene trees represent duplication nodes under
Fig. 9.
Mapping for the tree when , and the tree when but
We now prove the hardness of the MPRST-SD problem. For convenience, we repeat the illustration of the construction.
Let G and be a given instance of vertex cover, and let and S be constructed as described before. Call a node an original duplication if v is a duplication under . If , we might call v an original s-duplication for more precision. For and , suppose there is a unique node such that . We then denote w by T[t]. In particular, any special node that is present in a tree satisfies the property, so when we mention the special uv nodes of T, we refer to the special nodes that are mapped to the corresponding special uv nodes in S under . For example in the tree of Fig. 3, the indicated set of nodes are called special nodes as they are mapped to the special nodes of S under .
We now show that G has a vertex cover of size if and only if and S admit a mapping of cost at most .
() Suppose that is a vertex cover of G. We describe a mapping such that for each :
If , then and ;
If , then and
and for every other node .
Summing over all , a straightforward verification show that this mapping attains a cost of
It remains to argue that each tree can be reconciled using these duplications heights. In the remainder, we shall view these duplication heights as “free to use”, meaning that we are allowed to create a duplication path of nodes mapped to , as long as this path has at most nodes, using defined above.
Let be one of the A trees, . If is in the vertex cover, then we have put . In this case, setting for every node w in is a valid mapping in which described above is respected for all (the only duplications in are those 10K mapped to ). If instead , then we may set for all the 10K original -duplications of , and set for every other node. This is easily seen to be valid since the ancestors of the original -duplications in are all proper ancestors of .
Let be a tree, . If , then , and so setting for all is valid and respects for all (since the duplication is mapped to and there are no other duplications). If , then set for every node between the original -duplication in and and set for every other node w. This creates a path of 10K duplications mapped to , which is acceptable since . This case is illustrated in Fig. 9.
Let be a C tree, . Let be the two endpoints of edge , with . Since is a vertex cover, we know that one of or is in . Suppose first that . In this case, we have set . Let w be the highest special node of (i.e. the closest to the root). We set for each internal node descending from w. All of these nodes become duplications, but the number of nodes of a longest path from w to an internal node descending from w is 10K (K for the subtree, plus 9K for the special nodes). Thus having is sufficient to cover the whole subtree rooted at w with duplications. All the proper ancestors of w can retain the LCA mapping and be speciations, since for all these proper ancestors .
Now, let us suppose that , implying . Note that for all . This time, let w be highest special node of . Again, we will make w and all its internal node descendants duplications. We map them to the set . This case is illustrated in Fig. 9.
More specifically, the longest path from w to a descending internal node contains , where we have counted the special nodes, the special nodes, the special nodes and the subtree nodes. We have , just enough to map the whole subtree rooted at w to duplications. It is easy to see that such a mapping can be made valid by first mapping the 9K special nodes to , then the other nodes descending from w to the rest of . This is because all these nodes are ancestors of the special nodes, the special nodes and the nodes (except , but we have anyway).
We have constructed a mapping with the desired duplication heights, concluding this direction of the proof. Let us proceed with the converse direction.
: suppose that there exists a mapping of the trees of cost at most . We show that there exists a vertex cover of size at most in G. For some , define . For each , define the sets
and
Our goal is to show that the ’s for which correspond to a vertex cover. The proof is divided into a series of claims.
Claim 1
For each , .
Proof
Consider the tree of A, and let be an original -duplication in . If , then every node of on the path from to is a duplication. This includes all the special nodes, contradicting the cost of . Thus . That is, . As this is true for all the original -duplications of , and because and are disjoint sets, this shows that .
The above claim shows that we already need a duplication height of 10Kn just for the union of the and nodes. This implies the following.
Claim 2
There are at most duplication in that are not mapped to a node in . Moreover, for any subset , .
Proof
The first statement follows from Claim 1 and the cost of . As for the second statement, suppose it does not hold for some . Then , a contradiction to the cost of .
Now, let c be an original duplication in some tree of . The c -duplication path is the maximal path of T (treated as an undirected graph) that starts at c and contains only ancestors of c that are duplication nodes under (in other words, we start at c and include it in , traverse the ancestors one after another and include every duplication node encountered, and then stop when reaching a speciation or the root—every node in is a duplication). We will treat as a set of nodes. We say that ends at node p if and for every .
Claim 3
Let and let be the two endpoints of edge , with . Then there is an original duplication such that ends at a node p with .
Proof
Let be the original duplication nodes in the tree, which belong to the subtree of . Assume the claim is false, and that for every . First observe that if for every pair of original duplications in , then . Note that is impossible for , by the placement of the leaves in in the species tree S. As we further assume that for every k, none of the duplications is mapped to a member of either. Therefore, none of the duplications is counted in Claim 1, so this implies a cost of at least , a contradiction. So we may assume that for some distinct original duplications . Notice that must be a common ancestor of and . This implies that every node on the path between and is a duplication (by Lemma 3), which in turn implies , by the construction of . By assumption, no duplication of is mapped to a member of , and again due to Claim 1, the total cost of is at least , a contradiction.
We can now show that the sets for which correspond to a vertex cover.
Claim 4
Let , and let be the two endpoints of , with . Then at least one of or holds.
Proof
Assume that . By Claim 3, there is an original duplication c in such that ends at a node p satisfying . This implies that every special node in is a duplication (by Lemma 3). Thus contains all these 9K nodes, plus K nodes from the subtree. Since , at least K of these nodes are mapped to a node outside . Call U this set of K nodes that are not mapped in . By the placement of the subtree, none of the nodes of U is mapped to an element of for . Also by Claim 2, at most of the U nodes are mapped to a node outside of , so it follows that at least nodes of U are mapped to an element of W. Because all the elements of W are ancestors of the special nodes, this implies that all the special nodes in are duplications, of which there are .
So far, this makes at least duplications in . Let us now argue that at least one of these is mapped to an ancestor of (not necessarily proper). If not, then all the duplications considered in so far are mapped to , where X is some subset of V(S) satisfying . By Claim 2, we know that . In fact, this means that at least of the duplications considered in so far that are unaccounted for, which means that they are mapped to an ancestor of .
Because of this, we now get that the 9K special nodes of are duplications (which were not considered in so far). That means that at least duplications of are mapped to an ancestor of . Notice that cannot contain a node w with . Indeed, if this were the case, then all the special nodes of would be duplications, of which there are . Thus all the aforementioned duplications are mapped to an ancestor of but a proper descendant of , i.e. they are mapped in . So , proving our claim.
Let . Then Claim 4 implies that is a vertex cover. It only remains to show that . This will follow from our last claim.
Claim 5
Suppose that . Then .
Proof
Let be the original -duplication in the tree. We show that . If , then all the 10K nodes on the path from to , including itself, are duplications mapped to a node in (these nodes cannot be mapped to an ancestor of the nodes, due to the presence of the special nodes above ). Thus , and so , contradicting Claim 2. It follows that . Since we cannot have , we now know that . Using Claim 1 we have .
To finish the argument, Claim 5 implies that , since each implies that and that . More formally, if we had , letting , with , this would imply . This concludes the proof.
Footnotes
To our knowledge, this is the first publicly available reconciliation software for segmental duplications.
There is a subtlety to consider here. What we have shown is that if there exists a mapping of minimum cost with , then the algorithm finds it. It might be that a reconciliation satisfying exists, but that the algorithm returns no solution. This can happen in the case that is not of cost .
Note that for this data set we used a high value for since, because of the sampling strategy, we expect that all relevant genes have been sampled (recall that in ExactMGD, is implicitly set to 0).
Contributor Information
Riccardo Dondi, Email: riccardo.dondi@unibg.it.
Manuel Lafond, Email: manuel.lafond@USherbrooke.ca.
Celine Scornavacca, Email: celine.scornavacca@umontpellier.fr.
References
- 1.Bansal MS, Eulenstein O. The multiple gene duplication problem revisited. Bioinformatics. 2008;24(13):132–138. doi: 10.1093/bioinformatics/btn150. [DOI] [PMC free article] [PubMed] [Google Scholar]
- 2.Butler G, Rasmussen MD, Lin MF, Manuel Santos AS, Sakthikumar S, Munro CA, Rheinbay E, Grabherr M, Forche A, Reedy JL, et al. Evolution of pathogenicity and sexual reproduction in eight candida genomes. Nature. 2009;459(7247):657. doi: 10.1038/nature08064. [DOI] [PMC free article] [PubMed] [Google Scholar]
- 3.Cedric C, Nadia E-M. New perspectives on gene family evolution: losses in reconciliation and a link with supertrees. In: Annual international conference on research in computational molecular biology. Springer; 2009. p. 46–58.
- 4.Chauve C, Ponty Y, Zanetti JPP. Evolution of genes neighborhood within reconciled phylogenies: an ensemble approach. In: Brazilian symposium on bioinformatics. Springer; 2014. p. 49–56. [DOI] [PMC free article] [PubMed]
- 5.Chauve C, Rafiey A, Davin AA, Scornavacca C, Veber P, Boussau B, Szollosi G, Daubin V, Tannier E. Maxtic: fast ranking of a phylogenetic tree by maximum time consistency with lateral gene transfers. bioRxiv, 2017. https://www.biorxiv.org/content/early/2017/11/07/127548.
- 6.David LA, Alm EJ. Rapid evolutionary innovation during an archaean genetic expansion. Nature. 2011;469(7328):93. doi: 10.1038/nature09649. [DOI] [PubMed] [Google Scholar]
- 7.Davín AA, Tannier E, Williams TA, Boussau B, Daubin V, Szöllősi GJ. Gene transfers can date the tree of life. Nat Ecol Evol. 2018;2(5):904. doi: 10.1038/s41559-018-0525-3. [DOI] [PMC free article] [PubMed] [Google Scholar]
- 8.Delabre M, El-Mabrouk N, Huber KT, Lafond M, Moulton V, Noutahi E, Castellanos MS. Reconstructing the history of syntenies through super-reconciliation. In: RECOMB international conference on comparative genomics. Springer; 2018. 179–195.
- 9.Dondi R, Lafond M, El-Mabrouk N. Approximating the correction of weighted and unweighted orthology and paralogy relations. Algorith Mol Biol. 2017;12(1):1–4. doi: 10.1186/s13015-017-0096-x. [DOI] [PMC free article] [PubMed] [Google Scholar]
- 10.Duchemin W. Phylogeny of dependencies and dependencies of phylogenies in genes and genomes. Ph.D. thesis, Universit de Lyon, 2017.
- 11.Duchemin W, Anselmetti Y, Patterson M, Ponty Y, Bérard S, Chauve C, Scornavacca C, Daubin V, Tannier E. Decostar: reconstructing the ancestral organization of genes or genomes using reconciled phylogenies. Genome Biol Evol. 2017;9(5):1312–1319. doi: 10.1093/gbe/evx069. [DOI] [PMC free article] [PubMed] [Google Scholar]
- 12.Fellows M, Hallett M, Stege U. On the multiple gene duplication problem. In: International symposium on algorithms and computation. Springer; 1998. p. 348–357.
- 13.Goodman M, Czelusniak J, Moore GW, Romero-Herrera AE, Matsuda G. Fitting the gene lineage into its species lineage, a parsimony strategy illustrated by cladograms constructed from globin sequences. Syst Biol. 1979;28(2):132–163. doi: 10.1093/sysbio/28.2.132. [DOI] [Google Scholar]
- 14.Guigo R, Muchnik I, Smith TF. Reconstruction of ancient molecular phylogeny. Mol Phylogenet Evol. 1996;6(2):189–213. doi: 10.1006/mpev.1996.0071. [DOI] [PubMed] [Google Scholar]
- 15.Jacox E, Chauve C, Szllsi GJ, Ponty Y, Scornavacca C. Eccetera: comprehensive gene tree-species tree reconciliation using parsimony. Bioinformatics. 2016;32(13):2056–2058. doi: 10.1093/bioinformatics/btw105. [DOI] [PubMed] [Google Scholar]
- 16.Jacox E, Weller M, Tannier E, Scornavacca C. Resolution and reconciliation of non-binary gene trees with transfers, duplications and losses. Bioinformatics. 2017;33(7):980–987. doi: 10.1093/bioinformatics/btw778. [DOI] [PubMed] [Google Scholar]
- 17.Kellis M, Birren BW, Lander ES. Proof and evolutionary analysis of ancient genome duplication in the yeast saccharomyces cerevisiae. Nature. 2004;428(6983):617. doi: 10.1038/nature02424. [DOI] [PubMed] [Google Scholar]
- 18.Lafond M, Dondi R, El-Mabrouk N. The link between orthology relations and gene trees: a correction perspective. Algorith Mol Biol. 2016;11:4. doi: 10.1186/s13015-016-0067-7. [DOI] [PMC free article] [PubMed] [Google Scholar]
- 19.Lafond M, Miardan MM, Sankoff D. Accurate prediction of orthologs in the presence of divergence after duplication. Bioinformatics. 2018;34(13):i366–75. doi: 10.1093/bioinformatics/bty242. [DOI] [PMC free article] [PubMed] [Google Scholar]
- 20.Luo CW, Chen MC, Chen YC, Yang RW, Liu HF, Chao KM. Linear-time algorithms for the multiple gene duplication problems. IEEE/ACM Trans Comput Biol Bioinf. 2011;8(1):260–265. doi: 10.1109/TCBB.2009.52. [DOI] [PubMed] [Google Scholar]
- 21.Ma B, Li M, Zhang L. From gene trees to species trees. SIAM J Comput. 2000;30(3):729–752. doi: 10.1137/S0097539798343362. [DOI] [Google Scholar]
- 22.Maddison WP. Gene trees in species trees. Syst Biol. 1997;46(3):523–536. doi: 10.1093/sysbio/46.3.523. [DOI] [Google Scholar]
- 23.Nguyen TH, Ranwez V, Pointet S, Chifolleau AMA, Doyon JP, Berry V. Reconciliation and local gene tree rearrangement can be of mutual profit. Algorith Mol Biol. 2013;8(1):12. doi: 10.1186/1748-7188-8-12. [DOI] [PMC free article] [PubMed] [Google Scholar]
- 24.Page RDM. Maps between trees and cladistic analysis of historical associations among genes, organisms, and areas. Syst Biol. 1994;43(1):58–77. [Google Scholar]
- 25.Page RDM, Cotton JA. Vertebrate phylogenomics: reconciled trees and gene duplications. Pac Symp Biocomput. 2002;7:536–547. doi: 10.1142/9789812799623_0050. [DOI] [PubMed] [Google Scholar]
- 26.Paszek J, Gorecki P. Efficient algorithms for genomic duplication models. IEEE/ACM Trans Comput Biol Bioinf. 2017;15(5):1515–24. doi: 10.1109/TCBB.2017.2706679. [DOI] [PubMed] [Google Scholar]
- 27.Szöllősi GJ, Boussau B, Abby SS, Tannier E, Daubin V. Phylogenetic modeling of lateral gene transfer reconstructs the pattern and relative timing of speciations. In: Proceedings of the national academy of sciences, 2012. p. 201202997. [DOI] [PMC free article] [PubMed]
- 28.Szöllősi GJ, Daubin V. Modeling gene family evolution and reconciling phylogenetic discord. In: Evolutionary genomics. Springer; 2012. p. 29–51. [DOI] [PubMed]
- 29.To TH, Jacox E, Ranwez V, Scornavacca C. A fast method for calculating reliable event supports in tree reconciliations via pareto optimality. BMC Bioinf. 2015;16(1):384. doi: 10.1186/s12859-015-0803-x. [DOI] [PMC free article] [PubMed] [Google Scholar]
- 30.Ullah I, Sjöstrand J, Andersson P, Sennblad B, Lagergren J. Integrating sequence evolution into probabilistic orthology analysis. Syst Biol. 2015;64(6):969–982. doi: 10.1093/sysbio/syv044. [DOI] [PubMed] [Google Scholar]
Associated Data
This section collects any data citations, data availability statements, or supplementary materials included in this article.
Data Availability Statement
The implementation is available at https://github.com/AEVO-lab/MultRec. The data used in the experiments is available on demand.







