# Whole-genome duplication detection with phylogenomics reconciliation: a scalable approach.

Reza Kalhor, Manuel Lafond, Celine Scornavacca

► To cite this version:

Reza Kalhor, Manuel Lafond, Celine Scornavacca. Whole-genome duplication detection with phylogenomics reconciliation: a scalable approach.. RECOMB-CG, Apr 2025, Seoul, South Korea. hal-04987348

HAL Id: hal-04987348

https://hal.science/hal-04987348v1

Submitted on 10 Nov 2025

HAL is a multi-disciplinary open access
archive for the deposit and dissemination of sci-
entific research documents, whether they are pub-
lished or not. The documents may come from
teaching and research institutions in France or
abroad, or from public or private research centers.

L'archive ouverte pluridisciplinaire HAL, est
destinée au dépôt et à la diffusion de documents
scientifiques de niveau recherche, publiés ou non,
émanant des établissements d'enseignement et de
recherche français ou étrangers, des laboratoires
publics ou privés.

<figure><img src="image_1.png" /></figure>
Whole-genome duplication reconciliation-based
detection from phylogenomic data: a scalable
approach

Reza Kalhor¹, Manuel Lafond¹, and Celine Scornavacca²

¹ Department of Computer Science, Université de Sherbrooke, Sherbrooke, Canada
Reza.Kalhor@USherbrooke.ca

² Institut des Sciences de l'Evolution de Montpellier(Université de Montpellier, CNRS, IRD, EPHE), Montpellier, France

**Abstract.** Gene duplication plays a crucial role in species adaptation and the emergence of novel functions, making the inference of past duplication events key to understanding evolution. Whole-genome duplications (WGD), which copy all the gene families in a single event, had a significant impact on the evolution of plants, yeast, and even vertebrates. Genome-scale data is often used to retrace WGDs, for instance conserved syntenic blocks and gene counts, but ancient WGDs are notoriously difficult to retrace, as their signals tend to be lost in rearrangements and losses. An alternative approach consists in using phylogenies to infer ancient duplications. Reconciliation achieves this by comparing gene trees with species trees, though current tools often assume independent reconciliation of gene families. This assumption cannot handle WGDs, in which the opposite holds since all genes are part of the same event. While recent models have sought to address this through multi-gene phylogenomics reconciliation, they usually come with important limitations. For instance, they can restrict the space of possible reconciliations to achieve better efficiency, ignore gene losses that frequently occur after large-scale duplications, or rely on conserved syntenies across multiple species, which limits the number of genes that can be considered simultaneously and may miss ancient WGDs.

In this work, we focus on a reconciliation model that is synteny-free, that considers losses, and that allows flexible remapping of gene duplications. Reconciliation under this model was shown NP-hard and current exact algorithms are far from achieving the scalability needed for phylogenomics analysis. To overcome these limitations and establish the potential of this model, we introduce novel algorithmic techniques that enable efficient exploration of large datasets containing tens of thousands of gene trees, which was not possible before. Our experiments on simulations and real data demonstrate that the traditional lca-mapping can incorrectly infer ancestral gene mappings, especially in cases of WGD followed by fractionation, and show the robustness of our approach in handling complex duplication and loss patterns. Tests on real data also show the relevance of using our approach on large phylogenomic datasets, as it can recover WGDs that can be missed by both classical reconciliation methods, and by phylogenomics reconciliation methods that restrict the search space.
**Keywords:** Phylogenomics. Reconciliation. Whole genome duplications. Algorithms.

# 1 Introduction

Gene duplication is a fundamental mechanism for the development of novel functions and species adaptation [40]. Inferring past duplication events is therefore essential in understanding evolution, with applications ranging from reconstructing ancestral genomes [16] to inferring functionally similar genes [47,32,24]. Reconciliation is commonly used to infer gene-level events by explaining the discrepancies between a gene tree and a species tree [19]. In this paper, we shall consider duplications and losses as the only possible gene-level processes at work, for which there exist several reconciliation tools [15,26,17,7]. Most compare individual gene trees against a species tree, assuming that gene families can be reconciled independently, although it is well-known that macro-evolutionary events that can affect multiple genes exist. A striking example includes whole genome duplication (WGD), which doubles all of the gene content [40,31]. WGDs play a pivotal role in genetic diversity, having impacted eukaryotes evolution [41,33]. In plants, WGDs are believed to be largely responsible for speciation events [11], and approximately one-third of modern vascular plant species have undergone WGD [50]. A WGD took place roughly 100-150 Mya ago during the evolution of Saccharomyces yeasts [18,49] and significant milestones in fungal diversity have been linked to genome doubling [1]. Needless to say, inferring WGDs correctly is fundamental in understanding evolution.

Genome-scale data has often been used to detect WGDs. While conserved syntenic blocks or gene copy number counts can provide information on recent events, ancient WGDs involving distant species have time to scramble the genomes and leave little trace of conserved blocks [45,46]. This is exacerbated by fractionation, which tends to delete one of the gene copies quickly after the event [35,8,45,22]. Other approaches are based on $K_s$ rates, but suffer from similar issues [48]. This motivates us to turn to approaches based on phylogenies and reconciliation. Since reconciling gene families separately may miss WGD events, phylogenomics reconciliation incorporates multiple gene families simultaneously for the prediction of ancestral events. Guigó et al. [23] were among the first to extend reconciliation to multiple gene trees. They developed heuristics for this task, until Page and Cotton [42] formalized it into the Episodes Clustering (EC) problem, which asks to map the duplication events into a minimum number of species. This was later extended to a variant called Minimum Episodes (ME) [6], where the number of duplication rounds within each species is also counted. There are very efficient algorithms for these problems [6,9,34,38,44] and related variants (see e.g. [20], and [44] for a survey), but these models have inherent drawbacks. First, for these methods, the speciation events predicted by the lca-mapping –which maps genes to their latest possible species– usually cannot be contested. This in turn fixes the set of duplications a priori, before
searching for segmental events, which significantly reduces the space of consid-
ered reconciliations. Indeed, the range of possible species of ancestral genes is
limited by the lca-mapping speciations, even though several works argue that al-
ternate scenarios should be explored [14,5]. Second, these models do not consider
gene losses, even though they are informative as they often eliminate redundancy
after large-scale duplications.

Recently, Delabre et al. [12,4] introduced a multi-gene reconciliation model that does handle losses. They aim to reconstruct the evolution of syntenic blocks, which can be used to infer segmental duplication events. However, the scale of such events is limited by the size of detectable syntenies among dozens of species, which is usually small. The model also requires all the gene families within a block to evolve in compatible gene trees, making the approach not always usable in practice.

In this work, we focus on a reconciliation approach that avoids the aforemen-
tioned drawbacks: it infers segmental duplications in a model that is synteny-free,
that considers losses, and that is not restricted by the lca-mapping. The model
was introduced in [13] and, unlike previous multi-gene approaches, allows all
time-consistent gene-species maps and all speciation events to be relabeled to
duplications — the range of possible remappings of genes being naturally limited
by gene losses. Finding a most parsimonious reconciliation under this model was
shown to be NP-hard (see [13, Theorem 3]), but a O([δ/λ]^{d+1} · n) time algo-
rithm is known, where δ is the cost of a segmental duplication, λ is the cost of
a single loss, *d* is the minimum number of segmental duplications, and *n* is the
total number of nodes in the instance, including the gene tree nodes and the
species tree nodes.

Unfortunately, the implementation of this algorithm can only handle small
datasets, as it could not terminate even on modest simulated instances with
around 20 species and 100 gene trees. Moreover, the base [δ/λ] of the expo-
nential complexity only allows small duplication/loss ratios, which has the same
undesired effect of limiting the range of possible species of ancestral genes as pre-
vious work. Due to these limitations, the potential of the novel model has not
been fully explored. Since practical exact algorithms appear difficult to achieve,
we turned to heuristics to explore this question. In this paper, we introduce an
approach inspired by simulated annealing that starts with a given initial recon-
ciliation, then explores the solution space by performing gene remapping moves
until convergence. The supported moves include remapping a single gene to a
higher or lower species, or remapping a whole segmental duplication in a single
move.

Even with this simple strategy, the gargantuan size of the solution space
comes with algorithmic challenges. In datasets of moderate size, there can be
hundreds of thousands of possible moves, which need to be re-evaluated at each
iteration. Minimizing the computation time per iteration is therefore crucial,
leading to the combinatorial problem of evaluating the change in cost of each
move. We propose a dynamic programming algorithm that computes the cost
impact of each such move in O(1) amortized time, allowing phylogenomics reconciliation that scales to thousands of gene trees.

We implemented our approach in FastMultRec and performed extensive experiments to assess the potential in recovering large-scale segmental duplications. To our knowledge, the added value of phylogenomics reconciliation against the traditional lca-mapping has not been established clearly in the literature. It may well be that the latter performs just fine and that sophisticated reconciliation models are not needed. Our experiments say otherwise though. Indeed, in the presence of WGD, we show on simulations conducted using SimPhy [36] that the standard lca-mapping may map ancestral genes incorrectly, and even indicate incorrect WGD locations. This is mostly due to the fractionation and complex loss patterns that follows WGD, to which our approach exhibits more robustness. This trend is confirmed when analyzing three real datasets exhibiting one or more WGD: our approach correctly finds all known WGDs with little false positive, which is not the case for the lca method. We also compare our approach with MetaEC [20], the most recent implementation for the EC problem. We confirm that restricting the search space is indeed an important limitation, as the explored scenarios often provide the same information as the lca method. This shows that more complex models such as ours are necessary to find large-scale duplications.

## 2 Methods

We first formalize our reconciliation model, then discuss our efficient exploration of the solution space. We use the standard notions of trees, forests, height, and distance. The root of a tree $T$ is denoted $r(T)$; its set of leaves is $L(T)$ and its height is $h(T)$. The distance between two nodes $u, v$ of $T$ is $dist_T(u, v)$. The set of trees in a forest $F$ is denoted $t(F)$. The leaves of $F$ are $L(F) = \bigcup_{T \in t(F)} L(T)$, and the height of $F$ is $h(F) = \max_{T \in t(F)} h(T)$. The subgraph of $F$ induced by $X$ is denoted $F[X]$. For $u, v \in V(F)$ in the same tree, we write $u \preceq_F v$ if $u$ is a descendant of $v$, and $u \prec_F v$ when $u \neq v$. Two nodes $u, v$ of $F$ are incomparable if neither is an ancestor of the other. If $X \subseteq L(F)$ is a set of leaves that all belong to the same tree of $t(F)$, we write $lca_F(X)$ for the lowest common ancestor of $X$. We may drop the subscript $F$ in the notation if unambiguous.

**Reconciliations.** A gene tree is a tree in which the leaves contain extant genes, and a gene forest is a forest $G$ of gene trees. A species tree is a tree $S$ in which $L(S)$ is a set of extant species. A leaf species map is a function $\sigma: L(G) \to L(S)$ that assigns each extant gene to its extant species.

Given a gene forest $G$, a species tree $S$, and a leaf species map $\sigma$, a reconciliation is a map $m: V(G) \to V(S)$ that assigns each gene forest node to a species node. Moreover, $m$ must satisfy the following conditions:

1. *preserve leaf maps*: for each $u \in L(G)$, $m(u) = \sigma(u)$;

2. *time consistency*: for each non-root node $u \in V(G)$ with parent $p_u$, we have $m(u) \preceq_S m(p_u)$.

The lca-mapping between $G$ and $S$ is the unique reconciliation $\mu$ that assigns each node to the lowest possible species according to time-consistency (see Fig-
ure 1 top row). That is, for each internal node $u$ of $G$, $\mu(u) = \text{lca}_S(\{\sigma(w) : w \in L(G) \text{ and } w \preceq u\})$.

<figure><img src="image_2.png" /><figcaption>Fig. 1: Two possible reconciliations for a species tree $S$ and a forest of three gene trees. Each leaf is labeled by $\sigma$, the species that contains it, and internal nodes are labeled according to $\mu$ (top) or $m$ (bottom). Blue squares are *Dup* nodes, white circles are *Spec* nodes, and light gray edges are losses. The reconciliation $m$ can be explained with three segmental duplications (gray rectangles), whereas $\mu$ needs five.</figcaption></figure>

**Speciation, duplication, and loss.** We use an established framework [21,51] to infer whether each internal node of $G$ underwent a speciation (Spec) or duplication (Dup) event under a reconciliation $m$. In essence, we infer a speciation at $u$ if its children branched into two separate species. The event labeling under $m$ is the function $ev_m: V(G) \setminus L(G) \to \{\text{Spec}, \text{Dup}\}$ that, for each $u \in V(G)$ with children $u_1, u_2$, puts:

$$ev_m(u) = \begin{cases} \text{Spec} & \text{if } m(u_1) \text{ has children } x_1, x_2 \text{ s.t. } m(u_1) \preceq_S x_1, m(u_2) \preceq_S x_2 \\ \text{Dup} & \text{otherwise.} \end{cases}$$

In words, a *Spec* node is such that its two children split into two separate species, and otherwise it is a *Dup* node. A node $u \in V(G)$ with $m(u) = s$ and $ev_m(u) = Dup$ is called an *s-duplication* (with respect to $m$). As an example, in middle gene tree of Figure 1, the node mapped to $X$ according to $\mu$ is a *Spec* (top), but the same node mapped to $Y$ according to $m$ is a *Dup* (bottom).

Gene losses are counted on the branches of $G$ by listing the species that should be present but are not. For an edge $uv \in E(G)$, the number of losses $l_m(uv)$ on $uv$ is $dist_S(m(u), m(v)) - 1$ if $ev_m(u) = \text{Spec}$, and $dist_S(m(u), m(v))$ if $ev_m(u) = \text{Dup}$. The total number of losses under $m$ is $l_m = \sum_{uv \in E(G)} l_m(uv)$.

**Segmental duplications.** For a species $s \in V(S)$, the duplication forest of $s$ (under $m$), denoted $F_m(s)$, is the subgraph of $G$ induced by $s$-duplications. Formally: $F_m(s) = G[\{v \in V(G) : m(v) = s, ev_m(v) = Dup\}]$. A *segmental duplication* is a single duplication event that may contains multiple genes. Such genes must coexist in the same species and must be incomparable in $G$ and $F_m(s)$, and so it is not hard to see that the smallest possible number of segmental duplications
duplications in species *s* is the height of *F*<sub>*m*</sub>(*s*), which we recall is *h*(*F*<sub>*m*</sub>(*s*)). The total number of segmental duplications in *m* is thus *d*<sub>*m*</sub> = Σ<sub>*s*∈*V*(<i>S</i>)</sub> *h*(*F*<sub>*m*</sub>(*s*)). For example in Figure 1, *d*<sub>μ</sub> = 5 (two duplications in *Y*, one in *X*, *A*, *C*), whereas *d*<sub>*m*</sub> = 3 (two duplications in *Y*, one in *C*). Observe that we also treat the duplication of a single as a special case of a segmental duplication. We can finally state our problem formulation.

The MOST PARSIMONIOUS SEGMENTAL RECONCILIATION problem

**Input:** a gene forest *G*, a species tree *S*, a leaf species map *σ*, and a duplication cost *δ* and loss cost *λ*.

**Goal:** find a reconciliation *m* between *G* and *S* that minimizes the cost *δ* · *d*<sub>*m*</sub> + *λ* · *l*<sub>*m*</sub>.

**Efficient exploration of the solution space**

To solve the above problem, we propose the following strategy to explore the
space of reconciliations:

1) start with an initial reconciliation *m* (typically the lca-mapping *μ*);

2) for each gene node $u \in V(G)$, and for each species $s$, compute the change in cost if we remap $u$ to $s$;

3) choose one of the moves from the previous step according to some criteria, and apply it;

4) repeat step 2 and 3 until no more moves need to be considered.

The types of “remapping moves” that we consider at step 2 follows, and then
we discuss step 3.

**Up-moves.** Let $u \in V(G)$ and $s \succ m(u)$. Remapping $u$ to $s$ may create time-inconsistencies with its parent $p_u$, for instance if we remap $u$ to a species that pre-existed $m(p_u)$. Our moves can thus also remap ancestors to preserve time-consistency. See Figure 2 left box for an example, where remapping $u$ to $Z$ enforces remapping all the ancestors in $Y$. The *up-remapping of u to s* is another

<figure><img src="image_3.png" /><figcaption>Fig. 2: An illustration of up-moves and bulk up-moves. Left: the species tree *S*. Middle: a portion of a gene tree undergoing an up-move that remaps *u* from *X* to *Z*. To satisfy time-consistency, the parent and grand-parent of *u* must also be remapped to *Z*, which creates a chain of duplications in *Z* and additional losses. Right: a bulk up-move that takes the earliest segmental duplication in *Y* spanning two gene trees, which consists of the roots of the trees in *F*<sub>*m*</sub>(*Y*), and remaps them to the species *Z*.</figcaption></figure>
mapping $m[u \to s]$ in which:

(1) $m[u \to s](w) = s$ for every ancestor $w$ of $u$ such that $m(w) \prec s$ (including $u$);

(2) $m[u \to s](w) = m(w)$ for every other node of $G$.

The astute reader may ask whether up-moves that remap parents are necessary, as it would be simpler to only consider moves that do not remap the parent. Let us call the latter a *simple up-move*. The middle gene tree in Figure 1 shows the advantage of the more complex type of up-moves. In that tree, we would like the *A*-duplication to be remapped to *Y* to save one duplication, but with simple moves we would need to remap *X* to *Y* first. However, that moves does not decrease the number of segmental duplications, but increases the number of losses, so it is strictly worse. The more complex remap from *A* to *Y* lets us find an improved reconciliation directly, without having to go through a worse reconciliation first.

**Bulk up-moves.** We may need to remap several genes upwards to save a segmental duplication. One way is to take the genes in the same segmental duplication in some species $s$, and move that duplication to an ancestor of $s$. For $s \in V(S)$ and $t \succ s$, the *bulk up-remapping from $s$ to $t$* is another mapping $m[s \to t]$ in which, for every root $u$ of the forest $F_m(s)$, we apply the up-move that remaps $u$ to $t$ (in any order).

Such bulk up-moves always reduce the height of $F_m(s)$, although they can increase the duplication height of other species. This is illustrated in Figure 2, where the roots of the *Y* duplication forest are all remapped to *Z*, thereby reducing the number of segmental duplications in *Y*, but increasing those in *Z* in this case.

**Down-moves.** A down-move remaps $u \in V(G)$ to a species $s$ below $m(u)$. Since $\mu(u)$ is the lowest possible, such an $s$ must satisfy $\mu(u) \le s \prec m(u)$, and we may need to remap descendants of $u$ to $s$ to avoid time-inconsistencies. The *down-remapping of $u$ to $s$* is another mapping $m[u \to s]$ in which:

(1) $m[u \to s](w) = s$ for every descendant $w$ of $u$ such that $m(w) \succ s$ (including $u$);

(2) $m[u \to s](w) = m(w)$ for every other node of $G$.

We note that if a down-move is available on a gene tree node $u$, then $m(u) \succ \mu(u)$, that is, before the remap $u$ is mapped above its lca. In this case, it is known that $u$ must be a *Dup* node (see e.g. [13, Lemma 2]). If the down-move is $m[u \to \mu(u)]$, then $u$ is remapped to $\mu(u)$ with a down-move, and it is *possible* that $u$ changes from a *Dup* node to a *Spec*, and even its parent $p_u$ can become a *Spec*. This contrasts with up-moves: because these remap a node $u$ above $\mu(u)$, the up-remapped node will always be a *Dup*, and up-moves can instead turn *Spec* into *Dup* nodes. Because of these differences, the two types of moves require different algorithms.

**Bulk down-moves.** As for up-moves, several genes may be remapped “downwards” at once to save a duplication (or more). Here, we take the deepest segmental duplication in $s$, and move it to a lower species.
For $s \in V(S)$ and $t \prec s$, the bulk remapping from $s$ to $t$ is another mapping $m[s \to t]$ that takes each deepest leaf $u$ of $F_m(s)$, that is, every $u$ of maximum depth $h(F_m(s))$, and applies the down-remapping of $u$ to $t$. If such a down-move is not possible because $\mu(u) \preceq t \prec s$ does not hold, then $m[s \to t]$ is invalid.

**Strategies and bottlenecks.** We consider two strategies to implement Step 3) above, which chooses a move. The greedy strategy simply chooses the move that yields the lowest reconciliation cost. The stochastic strategy assigns each possible reconciliation $m'$ a weight $w_{m'} = e^{c/(kT)}$, where $c$ is the cost of $m'$, $k$ is the Boltzmann constant and $T$ is a user-specified temperature parameter. It then normalizes the weights to obtain a probability distribution and then chooses randomly. We stop when convergence is reached or when a specified maximum number of iterations is achieved.

The main bottleneck of our exploration procedure is Step 2), the computa-
tion of cost changes of each move. Its complexity controls the number of iter-
ations we can perform in reasonable time. A naive implementation takes time
$O(|V(G)|^2h(S))$ to compute every entry, per iteration (see appendix). Since we
need to scale to gene forests with thousands of trees and tens of thousands of
nodes, a quadratic dependency on $|V(G)|$ is not acceptable. In the following, we
aim for an amortized time of $O(1)$ per entry.

**Computing the change in cost of up-moves.** We describe a dynamic pro-
gramming strategy to compute up-moves quickly. The full algorithm is somewhat
involved, so here we present the main idea and refer the interested reader to the
appendix for details. Consider an up-move $m[u \to s]$ that remaps $u$ to $s \succ m(u)$.
For any $t \in V(S)$, we denote $\Delta(u, s, t) = h(F_{m[u \to s]}(t)) - h(F_m(t))$, which is
the change in duplication height in species $t$ after remapping $u$ to $s$. Then de-
note $\Delta(u, s) = \sum_{t \in V(S)} \Delta(u, s, t)$, the total change in duplication heights after
remapping $u$ to $s$.

If we calculate those in pre-order on $G$ (i.e, parents are handled before chil-
dren), then we can re-use the information from the parents and only need to
calculate a constant number of entries.

**Lemma 1.** Let $u \in V(G)$ and let $s \in V(S)$ be an ancestor of $m(u)$. If $u$ is a root, or if $u$ has parent $p_u$ satisfying $s \prec m(p_u)$, then $\Delta(u, s) = \Delta(u, s, s) + \Delta(u, s, m(u))$. Otherwise, $u$ has a parent $p_u$ satisfying $s \succeq m(p_u)$, in which case $\Delta(u, s) = \Delta(p_u, s) - \Delta(p_u, s, s) - \Delta(p_u, s, m(u)) + \Delta(u, s, s) + \Delta(u, s, m(u))$.

*Proof (sketch).* If $u$ is a root, it suffices to notice that only $u$ gets remapped, and only the heights in $m(u)$ and $s$ can change. If $s \prec m(p_u)$, again only the $u$ gets remapped, and the type of $p_u$ (*Spec* or *Dup*) does not get affected, and the same argument applies. In the last case where $s \succeq m(p_u)$, the up-move only affects duplications in $s, m(u)$, or $t$ with $m(u) \prec t \prec s$. For those, the set of $t$-duplications that get removed is the same whether we remap $u$ to $s$ or $p_u$ to $s$, because such a duplication must be a strict ancestor of $u$. Hence the difference in duplication heights for those $t$'s is already counted in $\Delta(p_u, s)$. It is possible to have differences in $s$ or $m(u)$ though, so we take $\Delta(p_u, s)$, remove $\Delta(p_u, s, s)$
and $\Delta(p_u, s, m(u))$ which could be different, and replace them with $\Delta(u, s, s)$ and $\Delta(u, s, m(u))$.

As a consequence of Lemma 1, using a top-down approach, one can obtain $\Delta(u, s)$ by reusing $\Delta(p_u, s)$ and computing only four additional values, at most. This is far from being over though, as these are not trivial to obtain in $O(1)$ time each. They require information from other trees in the input forest, which in turn require maintaining auxiliary data structures efficiently — but ultimately it can be done. In a similar fashion, we can also compute the change in number of losses after remapping $u$ to $s$, which we denote as $\Lambda(u, s)$. This can also be achieved by reusing $\Lambda(p_u, s)$, and then we only need to look around $u$ locally to infer additional losses. Those techniques are all detailed in the appendix, as well as the analogous bottom-up algorithms to compute the change in costs of down-moves. The summary of our technical results is the following (by amortized time, we mean that each entry takes time $O(1)$ to compute on average).

**Theorem 1.** *Given a gene forest G, a species tree S, and a reconciliation m, the values of $\Delta(u, s)$ and $\Lambda(u, s)$ for up-moves and down moves can be computed in amortized time $O(1)$ per entry.*

**Estimating bulk up-moves and bulk down-moves** It is quite challenging to compute the exact change in cost of every possible bulk move efficiently. We thus focus on moves that are guaranteed to be advantageous, and use upper bounds on their change in cost. Recall that in a bulk up-move $m[s \to t]$, we remap all the roots of the s-duplication subtrees of $F_m(s)$ to $t$. With the data structures necessary to achieve Theorem 1, these are easy to obtain. The move reduces the height in s-duplications by 1, but might increase the height in other species. If such an increase happens, no reduction in segmental duplications occurs and because up-moves create losses, the move will not be advantageous and we ignore it. We can detect this situation efficiently, and in the end we only consider bulk up-moves that reduce the number of segmental duplications by 1. The number of losses of a bulk up-move can be estimated as the sum of losses created by moving each gene individually, stored when computing the $\Lambda$ values. For bulk down-moves, we use a similar idea — when considering a move $m[s \to t]$ with $t \prec s$, we take all the deepest nodes in the forest $F_m(s)$, and try to remap those to $t$. If this is invalid, or if such a remapping would increase the number of segmental duplications, we ignore the move. We can show that the list of candidate bulk moves can be built in total time $O(|V(G)|h(S))$, which does not add complexity to Theorem 1.

## 3 Results

We implemented both the greedy and stochastic approaches described in the previous section. The source code of our new method FastMultRec is available at https://github.com/r3zakalhor/FastMultRec. We report the results from the greedy version, since, in our simulations, the stochastic version took
much longer to terminate and did not produce meaningfully better results<fnref n="3" />. We evaluated our algorithms on (i) simulated trees with known WGD locations on the species tree; and (ii) three real datasets with well-documented WGDs. Our goal on the simulations was simply to validate that our model provides added value against the lca-mapping. On real data, we added a comparison against MetaEC [20], which solves the Episode Clustering problem. We do not compare our results with the exact algorithm developed in [13]. The reason for this is that this implementation could not terminate in reasonable time on either our simulated datasets or real data — except for very small $δ/λ$ rates such as $δ = 3, λ = 2$. Even with this setting, the software takes more than 8 hours to terminate on a single dataset, and gives the same result as the lca mapping (mainly because such a low $δ/λ$ leaves no room to remap a gene). [ML: why not compare vs MetaEC in the simulations?]

**Simulation of species and gene trees.** We used SimPhy [36], a comprehensive simulator for the evolution of gene families in a species tree. Since SimPhy cannot replicate the effects of a WGD, we borrowed ideas from [20] and planted WGDs by simulating a species tree, copying one of its subtrees, and letting SimPhy evolve on the modified species tree. One key aspect to consider after a WGD is *fractionation*: since duplicated genes become redundant, there is often a gradual loss of one copy to restore genomic balance and reduce metabolic costs [35,8,45]. Without such loss patterns, the lca-mapping usually performs well, so we focus on the quality of reconciliation when fractionation occurs (which is also more biological relevant). We enforced it in a post-processing step: in each gene tree $G$, each leaf $v$ was deleted with probability $(n-1)/n$, where $n$ is the number of leaves of $G$ in the same species as $v$. We used several duplication and loss rates: fixed rates (F) between 1e-6 and 1e-18; uniformly distributed (U) per species node in the range [1e-12,1e-6]; lognormally distributed (LN) with location in [-25,-15] and scale in {0.1, 0.3, 1}. Incomplete Lineage Sorting (ILS) and gene transfers were not activated, although in the appendix, their effects were replicated with nearest neighbor interchanges (NNI) on the gene trees. For each parameters, we generated 100 simulations (called runs), each with 100 gene trees and a species tree having between 30 and 80 leaves, chosen randomly.

**Evaluation metrics.** We first compared our inferred gene-species maps against the lca-mapping, using the (known) simulated maps as our ground truth. We used the *path distance metric* for this purpose [39]. Given the true SimPhy map $s$ and an inferred map $m$, the path distance is $\text{pathdist}(s, m) = \sum_{v \in V(G)} \text{dist}_S(s(v), m(v))$, i.e., the sum of distances between the true and inferred species for each gene. Our values of path distances were similar to the lca-mapping, see appendix. A more appreciable difference was seen when quantifying the percentage of improvement over lca. Given the true SimPhy maps $s_1, \dots, s_{100}$ on the 100 gene trees of one simulation, our inferred maps $m_1, \dots, m_{100}$, and the lca-maps $\mu_1, \dots, \mu_{100}$ we

<footnote n="3">³ Note that the $O(1)$ time computation described in the appendix was used for the up-remap but a slightly slower algorithm was used for down-moves as they are much more complex to implement, and were more rarely useful.</footnote>
computed: Improvement (%) = $\left(1 - \frac{\sum_{i=1}^{100} \text{pathdist}(s_i, m_i)}{\sum_{i=1}^{100} \text{pathdist}(s_i, \mu_i)}\right) \times 100$. Note that the denominator was never 0 in our experiments. We also assessed our ability in recovering WGD events. We posited that a species is considered to have undergone a WGD if it exhibits a duplication in more than 80% of the gene trees. Given the known planted WGDs, for our approach and the lca-map, we calculated the number of true positives/negatives and false positives/negatives, from which we obtained precision and recall values.

<figure><img src="image_4.png" /><figcaption>Fig. 3: Left: Improvement % with one WGD, average over 100 SimPhy runs. Right: difference between the number of duplications per species (this example uses one run with D&L rate F:1e-11).</figcaption></figure>

**Simulations results.** Figure 3 on the left shows the improvement percentage on path distances for duplication costs $\delta \in \{2, 5, 30, 100\}$ (the loss cost $\lambda$ is 1). Note that $\delta \le 1$ yields the lca-mapping [13]. Smaller $\delta$'s make conservative moves, since remapping a gene much higher than its lca creates too many losses for its worth. Thus for $\delta = 2$, the improvements are smaller but present. At the other extreme, for $\delta = 100$ (equal to the number of gene trees), genes are remapped aggressively. On smaller D&L rates, most duplications are due to the planted WGD, in which case these remaps can recover it. Under most extreme and highly variable rates, most duplications are punctual, making it difficult to distinguish them from WGDs — with $\delta = 100$, we tend to cluster those duplications in one species, leading to negative improvements. This suggests that when the WGD signals are buried under other duplications and we are too permissive in remapping, the latter get remapped incorrectly. On the right, the figure gives an idea of how a good improvement % occurs. For each species (x-axis), it shows the difference (y-axis) between the number of predicted duplications in that species versus the true number of duplications (so, 0 means equal predictions). As shown, the lca-mapping may over-predict duplications in a non-WGD species and under-predict them in the WGD species — with high enough $\delta$, we fix all these errors and obtain improved maps.
Figure 4 shows the obtained precision and recall for one and two WGDs. Precision is generally high in most cases (notice the y-axis starts at 0.92), meaning that the number of false positive WGDs is low. We observe a slightly worse precision when two WGDs are present, but generally speaking getting WGDs signals from non-WGDs is unlikely. Recall is also generally high, with two obvious down-spikes for the lca-mapping. Those occurs at duplication rate 1e-6 and at the highly randomized lognormal rate, and low recall indicates that false negatives can occur. We refer to the discussion section for possible explanations of these results. We also applied NNIs on the simulated trees to test for robustness (see appendix). In most cases, obtain better recall and precision even on high levels of NNIs, but in a few cases obtained a slightly lower precision under extreme duplication and NNI rates.

<figure><img src="image_5.png" /><figcaption>(a) Recall of WGD for simulations with 1 WGD and 2 WGD, averaged over 100 runs.</figcaption></figure>

<caption>(b) Precision of WGD for simulations with 1 WGD and 2 WGD, averaged over 100 runs.</caption>

Fig. 4: Recall and Precision of detected WGDs, with one or two planted WGDs. Each result is an average derived from 100 simulation runs, ensuring reliability and robustness of the findings.

## Results on real datasets

We compared our results on three real datasets against the lca-mapping and MetaEC. The latter restricts *Spec* nodes to remain *Spec*, which limits the range of possible remaps for duplications, and finds a reconciliation that minimizes the number of species with one or more duplication under this constraint<fnref n="4" /> (note that we searched for other implementations, but all of [9,6,34,38,44] either provide no link to an implementation, or provide a dead link). We report the number of gene

<footnote n="4">⁴ Note that MetaEC can also handle genes from unknown species, although we did not use this feature, in which case MetaEC is very fast and terminates within minutes even on the largest datasets.</footnote>
trees that support a duplication in each of the ancestral species. We adjusted $\delta$ to the dataset sizes, see discussion. Note that again, we do not compare these results with those of [13]. The experiments in that paper were only performed with small $\delta/\lambda$ values and, for that reason, gave the same reconciliation as the lca-mapping.

**Eukaryotes dataset.** The first dataset we analyzed consists of 53 gene trees from 16 eukaryote species, introduced by Guigó et al. in [23] and previously analyzed in [6,43,13]. In Figure 5, each internal node is labeled as A/B, where A is the node identifier, and B represents the number of gene trees supporting duplications at that species. In [23], four segmental duplications were identified at nodes 6, 22, 28, and 30, supported by 6, 17, 9, and 13 gene trees, respectively. Additionally, two consecutive segmental duplications were observed at node 28 (that is, the height of the *s*-duplication forest is 2, where *s* is node 28). If we focus on the species in which at least one gene tree supports the duplication, as in [13], Figure 5b shows that our method detects the same segmental duplications at nodes 6, 22, 28 (including two consecutive duplications), and 30, with the same number of supporting gene trees as reported in [23], using a setup where $\delta = 50$ and $\lambda = 1$. On the other hand, Figure 5a shows that the lca-based method incorrectly identifies nodes 12 and 26 as nodes where a segmental duplication, or a series of (segmental) duplications, may have occurred. On this dataset, MetaEC found the same reconciliation as ours, and was thus also able to reproduce the results of Guigó et al.

**Yeast dataset.** We also analyzed the yeast species dataset as presented in [10], restricted to 1,746 gene trees containing all 16 species. To refine unsupported branches, we employed the method detailed in [27] and implemented in ecceTERA [26], using a bootstrap threshold of 0.9 and setting $\delta = \lambda = 1$. Figure 6b demonstrates that our method identifies two significant segmental duplications at nodes 10 and 16, which have been proposed as WGDs in [37] (respectively the “pre-KLE branch” and the “WGD” in Fig. 1 of the paper). Additionally, the two hotspots of duplications at nodes 6 and 29 are suggested by both our algorithm and the lca method. For both nodes, almost all gene trees depicting a duplication on these nodes show apparent duplications (i.e. shared labels between the right and the left child subtrees of the node) so these two hotspots of duplications seem to be robust. Note that node 6 has been indicated in [37] to have a duplication peak (node “n8” in Fig. 1 of the paper). Node 29 is not present in the dataset of [37] but several small-scale segmental duplications, often near the telomeres, are known to have happened in these species and can explain the duplication peak we observe for this node. The lca-mapping confirms only one WGD at node 10, see Figure 6a, and node 15 is identified as a hotspot of duplications by lca but with less than 10% of the gene trees showing apparent duplications; our method relocates these duplications to the parent node, resulting in node 16 being classified as a WGD. As for MetaEC, it produced the same reconciliation as the lca-mapping and thus provided no additional information. This is likely due to the large number of gene trees, see discussion.
<figure><img src="image_6.png" /><figcaption>(a) Segmental duplications detected by the lca-mapping shown as gray circles.</figcaption></figure>

<caption>(b) Segmental duplications detected by FastMultRec ($\delta = 50$, $\lambda = 1$) shown as gray circles. MetaEC yielded the same result as ours.</caption>

Fig. 5: Species tree of 16 eukaryotes studied by Guigó et al for 53 gene trees. Nodes are labeled with two numbers (A/B), with A the node identifier and B the number of gene trees supporting duplications in A.

**Fish dataset.** The final dataset we analyzed consists of 12,443 gene trees for 14 fish species [25]. In Figure 7b, two major segmental duplications are identified at nodes 24 and 3, both of which align with previous findings of a WGD at the base of teleost fishes (3R) [3,28], and a second one at the base of salmonid fish (4R)[2]. Nodes 18 and 12 are identified as segmental duplications by our method but respectively only 3,5 % and 0,8 % of the gene trees depicting a duplication on these nodes show apparent duplications; the percentage is almost 100% for nodes 24 and 3. We can thus discard nodes 18 and 12 as false positives. On the contrary, the lca-mapping misses the WGD at node 24 and identifies several hotspots of duplications that are not confirmed by the literature, see Figure 7a. Again, MetaEC produced the same reconciliation as the lca-mapping.

## 4 Discussion

Our experiments show that when large-scale duplications followed by fractionation occurs, the traditional lca-mapping is prone to mistakes, and alternate scenarios need to be explored. We believe this is because the lca-mapping is too parsimonious in the presence of losses. When duplications of a gene occur in a species, each copy creates its own gene subtree. Fractionation may then delete genes among these incomparable subtrees. The missing species in those then makes the lca-mapping assign the subtree roots too low, thereby hiding the sig-
<figure><img src="image_7.png" /><figcaption>(a) WGD (black circles) and Segmental duplications (gray circles) detected by lca. MetaEC produced the exact same reconciliation as the lca-mapping.</figcaption></figure>

<caption>(b) WGD (black circles) and Segmental duplications (gray circles) detected by our algorithm where $\delta = 1700$, $\lambda = 1$.</caption>

Fig. 6: Species tree of 16 yeast species for 1,746 gene trees. Each node is labeled with two numbers (A/B), where A is the node identifier and B is the count of gene trees supporting duplications in that species.

nal of the actual WGDs. Our approach can up-remap those roots and obtain a better recall. In our simulations, this is more prevalent in the highest duplication rate 1e-6, probably because the fractionation process deletes more genes overall and increases the chances of loss patterns that create errors. It is important to note that without fractionation, the lca-mapping made much less mistakes in our experiments (results not shown). Therefore, unless fractionation is known to be absent on a dataset, FastMultRec should be used as a tool to infer hypotheses on WGD locations that need to be validated through other means.

Although our work focused on WGDs, the model could also be used to detect segmental duplications on a smaller scale. As we have seen on real datasets, a significant number of duplications may be identified in some species, but the signal may be too weak to infer a WGD. It becomes difficult to decide whether such cases correspond to a large-scale duplication, or to a series of independent duplications events. Nonetheless, the tool can be used to find hotspots of duplications, which can then be investigated further.

**Autopolyploidy vs allopolyplody.** We must also reckon that duplication and loss models assume that genome doubling is due autopolyploidy, that is, intraspecies WGD. However, allopolyplody events can merge the genomes of separate species and produce hybrids with similar doubling effects. In fact, this was hypothesized to have occurred on the yeast dataset that we studied [37].
<figure><img src="image_8.png" /><figcaption>(a) WGD (black circles) and segmental duplications (gray circles) detected by the lca-mapping. MetaEC produced the exact same reconciliation.</figcaption></figure>

<figure><img src="image_9.png" /><figcaption>(b) WGD (black circles) and segmental duplications (gray circles) detected by our algorithm where $\delta = 10000$, $\lambda = 1$.</figcaption></figure>

Fig. 7: Species tree of atlantic salmon for 12,443 gene trees. Each node is labeled with two numbers (A/B), where A is the node identifier and B is the count of gene trees supporting duplications in that species.

As the authors argue, when this occurs reconciliation tends to infer duplication hotspots at the lowest common ancestor of the parents of the hybrid. This matches our observations. Although it is impossible to find hybridation events using a duplication and loss model, an interesting question is whether allopolyploidy leaves a signature that can be detected using our approach (or perhaps by checking the differences with the lca-mapping). Another direction is to include a notion of “segmental hybridation” in our model, perhaps by taking inspiration from reconciliation algorithms that can find horizontal gene transfers on whole genomes [29,30].

**Importance of not restricting the search space.** Our experiments found that MetaEC yielded the same results as the lca-mapping on our two largest real datasets. We did expect the approach to make *some* moves to save duplications, but upon closer inspection of the dataset, this can be explained by the restriction that *Spec* nodes must remain *Spec*. Consider for example the fish dataset, on which we move all the duplications in species 11 to species 12. If, under the lca-mapping, one such duplication *v* has a parent that is a *Spec* in 12, then *v* cannot be remapped at all under the EC constraints. This means that a duplication in node 11 *must* be present, making it pointless to move other duplications in 11. We validated that this was indeed the case on the dataset, and that the same phenomenon was present on the other species — as a result, MetaEC has no incentive to remap any node. In fact, this is hard to avoid on large datasets,
as more gene trees make this more likely to occur. This explains why MetaEC performs well on the Guigó et al. dataset with only about 50 gene trees. Note that this constraint is present in both the EC and ME formulations, and it is therefore crucial to overcome it by allowing flexible remappings in phylogenomics reconciliation.

**Impact of the duplication cost δ.** Recall that we fixed the loss cost λ = 1, and δ is used to weight the importance of duplications versus losses. As mentioned previously, a small δ infers maps that are close to the lca-mapping, whereas larger δ explore more scenarios. We recommend testing multiple costs when using FastMultRec to evaluate scenarios that cluster more and more duplications together — the segmental duplications that are never relocated even when increasing costs can be seen as more robust. We also note that δ can be set depending on the task at hand. A smaller δ is safer if accurate gene-species maps are required, as it rarely worsens the path distance metric. However, if WGDs need to be inferred, δ should be proportional to the number of input gene trees. This is because if the lca-mapping has *k* duplications mapped to the incorrect species, FastMultRec needs to up-remap those *k* nodes. This may save one duplication, but will create *k* losses, which will be considered detrimental if *δ* < *k*. This number *k* of incorrect maps likely increases with the number of gene trees, which is why this quantity should be proportional to *δ*.

**Running times and future improvements.** Our implementation took be-
tween 30 seconds and five minutes per SimPhy run, respectively with δ = 2 and
100, and finished in seconds on the Guigó dataset (all computations were done on
a standard desktop computer). For yeast and fish, the running times are highly
dependent on δ. On yeast, a solution is found within two hours when δ = 20,
but takes about a day on δ = 2000. On fish, the analysis took almost three
days with δ = 10000. This is mainly because the number of possibe moves, and
thus the explorable solution space, becomes larger as δ increases. Although the
running time per iteration does not increase much with higher δ, the number
of iterations needed to reach an unimprovable solution becomes much higher.
This could be improved by parallelizing the moves computations, and by using
more sophisticated data structures and techniques to maintain more information
across iterations. We currently recompute the change in cost of each move after
an iteration, although it is probably sufficient to reconsider only the affected
gene tree and affected species.

These technical improvements, coupled with other experiments on real data
sets aiming at detecting unknown WDGs, will be needed to unleash the full
potential of FastMultRec, which, to date, is the only solution that can infer
duplication-loss phylogenomics reconciliation in a model that is synteny-free,
that considers gene losses, and that can explore the solution space in an unre-
stricted manner.
References

1. Warren Albertin and Philippe Marullo. Polyploidy in fungi: evolution after whole-genome duplication. *Proceedings of the Royal Society B: Biological Sciences*, 279(1738):2497-2509, 2012.

2. Fred W Allendorf, Gray H Thorgaard, and BJ Turner. Evolutionary genetics of fishes. *Tetraploidy and the Evolution of Salmonid Fishes*, pages 55–93, 1984.

3. Angel Amores, Allan Force, Yi-Lin Yan, Lucille Joly, Chris Amemiya, Andreas Fritz, Robert K Ho, James Langeland, Victoria Prince, Yan-Ling Wang, et al. Zebrafish hox clusters and vertebrate genome evolution. *Science*, 282(5394):1711–1714, 1998.

4. Yoann Anselmetti, Mattéo Delabre, and Nadia El-Mabrouk. Reconciliation with segmental duplication, transfer, loss and gain. In *RECOMB International Workshop on Comparative Genomics*, pages 124–145. Springer, 2022.

5. Lars Arvestad, Ann-Charlotte Berglund, Jens Lagergren, and Bengt Sennblad. Bayesian gene/species tree reconciliation and orthology analysis using mcmc. *Bioinformatics-Oxford*, 19(1):7–15, 2003.

6. Mukul S Bansal and Oliver Eulenstein. The multiple gene duplication problem revisited. *Bioinformatics*, 24(13):i132–i138, 2008.

7. Mukul S Bansal, Manolis Kellis, Misagh Kordi, and Soumya Kundu. Ranger-dtl 2.0: rigorous reconstruction of gene-family evolution by duplication, transfer and loss. *Bioinformatics*, 34(18):3214–3216, 2018.

8. James A Birchler and Reiner A Veitia. The gene balance hypothesis: from classical genetics to modern genomics. *The Plant Cell*, 19(2):395–402, 2007.

9. J Gordon Burleigh, Mukul S Bansal, Andre Wehe, and Oliver Eulenstein. Locating multiple gene duplications through reconciled trees. In *Research in Computational Molecular Biology: 12th Annual International Conference, RECOMB 2008, Singapore, March 30-April 2, 2008. Proceedings 12*, pages 273–284. Springer, 2008.

10. Geraldine Butler, Matthew D Rasmussen, Michael F Lin, Manuel AS Santos, Sharadha Sakthikumar, Carol A Munro, Esther Rheinbay, Manfred Grabherr, Anja Forche, Jennifer L Reedy, et al. Evolution of pathogenicity and sexual reproduction in eight candida genomes. *Nature*, 459(7247):657–662, 2009.

11. Nico De Storme and Annaliese Mason. Plant speciation through chromosome instability and ploidy change: cellular mechanisms, molecular factors and evolutionary relevance. *Current Plant Biology*, 1:10–33, 2014.

12. Mattéo Delabre, Nadia El-Mabrouk, Katharina T Huber, Manuel Lafond, Vincent Moulton, Emmanuel Noutahi, and Miguel Sautie Castellanos. Reconstructing the history of syntenies through super-reconciliation. In *Comparative Genomics: 16th International Conference, RECOMB-CG 2018, Magog-Orford, QC, Canada, October 9-12, 2018, Proceedings 16*, pages 179–195. Springer, 2018.

13. Riccardo Dondi, Manuel Lafond, and Celine Scornavacca. Reconciling multiple genes trees via segmental duplications and losses. *Algorithms for Molecular Biology*, 14:1–19, 2019.

14. Jean-Philippe Doyon, Sylvie Hamel, and Cedric Chauve. An efficient method for exploring the space of gene tree/species tree reconciliations in a probabilistic framework. *IEEE/ACM Transactions on Computational Biology and Bioinformatics*, 9(1):26–39, 2011.

15. Jean-Philippe Doyon, Celine Scornavacca, K Yu Gorbunov, Gergely J Szöllősi, Vincent Ranwez, and Vincent Berry. An efficient algorithm for gene/species trees
parsimonious reconciliation with losses, duplications and transfers. In *Comparative Genomics: International Workshop, RECOMB-CG 2010, Ottawa, Canada, October 9-11, 2010*. Proceedings 8, pages 93–108. Springer, 2010.

16. Wandrille Duchemin, Yoann Anselmetti, Murray Patterson, Yann Ponty, Sèverine Bérard, Cedric Chauve, Celine Scornavacca, Vincent Daubin, and Eric Tannier. Decostar: reconstructing the ancestral organization of genes or genomes using reconciled phylogenies. *Genome biology and evolution*, 9(5):1312–1319, 2017.

17. Dannie Durand, Bjarni V Halldórsson, and Benjamin Vernot. A hybrid micro-macroevolutionary approach to gene tree reconstruction. *Journal of computational biology*, 13(2):320–335, 2006.

18. Toni Gabaldón. Hybridization and the origin of new yeast lineages. *FEMS Yeast Research*, 20(5):foaa040, 2020.

19. Morris Goodman, John Czelusniak, G William Moore, Alejo E Romero-Herrera, and Genji Matsuda. Fitting the gene lineage into its species lineage, a parsimony strategy illustrated by cladograms constructed from globin sequences. *Systematic Biology*, 28(2):132–163, 1979.

20. Paweł Górecki, Natalia Rutecka, Agnieszka Mykowiecka, and Jarosław Paszek. Unifying duplication episode clustering and gene-species mapping inference. *Algorithms for Molecular Biology*, 19(1):7, 2024.

21. Paweł Górecki and Jerzy Tiuryn. Dls-trees: a model of evolutionary scenarios. *Theoretical computer science*, 359(1-3):378–399, 2006.

22. Jean-Francois Gout, Yue Hao, Parul Johri, Olivier Arnaiz, Thomas G Doak, Simran Bhullar, Arnaud Couloux, Frédéric Guérin, Sophie Malinsky, Alexey Potekhin, et al. Dynamics of gene loss following ancient whole-genome duplication in the cryptic paramecium complex. *Molecular biology and evolution*, 40(5):msad107, 2023.

23. Guigó, Roderic and Muchnik, Ilya and Smith, Temple F. Reconstruction of ancient molecular phylogeny. *Molecular phylogenetics and evolution*, 6(2):189–213, 1996.

24. Marc Hellmuth, Nicolas Wieseke, Marcus Lechner, Hans-Peter Lenhof, Martin Midendorf, and Peter F Stadler. Phylogenomics with paralogs. *Proceedings of the National Academy of Sciences*, 112(7):2058–2063, 2015.

25. Russell A Hermansen, Torgeir R Hvidsten, Simen Rød Sandve, and David A Liberles. Extracting functional trends from whole genome duplication events using comparative genomics. *Biological procedures online*, 18:1–10, 2016.

26. Edwin Jacox, Cedric Chauve, Gergely J Szöllősi, Yann Ponty, and Celine Scornavacca. eccetera: comprehensive gene tree-species tree reconciliation using parsimony. *Bioinformatics*, 32(13):2056–2058, 2016.

27. Edwin Jacox, Mathias Weller, Eric Tannier, and Celine Scornavacca. Resolution and reconciliation of non-binary gene trees with transfers, duplications and losses. *Bioinformatics*, 33(7):980–987, 2017.

28. Olivier Jaillon, Jean-Marc Aury, Frédéric Brunet, Jean-Louis Petit, Nicole Stange-Thomann, Evan Mauceli, Laurence Bouneau, Cécile Fischer, Catherine Ozouf-Costaz, Alain Bernot, et al. Genome duplication in the teleost fish tetraodon nigroviridis reveals the early vertebrate proto-karyotype. *Nature*, 431(7011):946–957, 2004.

29. Lina Kloub, Sophia Gosselin, Matthew Fullmer, Joerg Graf, Johann Peter Gogarten, and Mukul S Bansal. Systematic detection of large-scale multigene horizontal transfer in prokaryotes. *Molecular Biology and Evolution*, 38(6):2639–2659, 2021.

30. Lina Kloub, Sophia Gosselin, Joerg Graf, Johann Peter Gogarten, and Mukul S Bansal. Investigating additive and replacing horizontal gene transfers using phylogenies and whole genomes. *Genome Biology and Evolution*, 16(9):evae180, 2024.
31. Elena Kuzmin, Benjamin VanderSluis, Alex N Nguyen Ba, Wen Wang, Elizabeth N Koch, Matej Usaj, Anton Khmelinskii, Mojca Mattiazzi Usaj, Jolanda Van Leeuwen, Oren Kraus, et al. Exploring whole-genome duplicate gene retention with complex genetic interaction analysis. *Science*, 368(6498):eaaz5667, 2020.

32. Manuel Lafond, Mona Meghdari Miardan, and David Sankoff. Accurate prediction of orthologs in the presence of divergence after duplication. *Bioinformatics*, 34(13):i366-i375, 2018.

33. Zheng Li, George P Tiley, Sally R Galuska, Chris R Reardon, Thomas I Kidder, Rebecca J Rundell, and Michael S Barker. Multiple large-scale gene and genome duplications during the evolution of hexapods. *Proceedings of the National Academy of Sciences*, 115(18):4713-4718, 2018.

34. Cheng-Wei Luo, Ming-Chiang Chen, Yi-Ching Chen, Roger WL Yang, Hsiao-Fei Liu, and Kun-Mao Chao. Linear-time algorithms for the multiple gene duplication problems. *IEEE/ACM Transactions on Computational Biology and Bioinformatics*, 8(1):260-265, 2009.

35. Michael Lynch and John S Conery. The evolutionary fate and consequences of duplicate genes. *science*, 290(5494):1151-1155, 2000.

36. Diego Mallo, Leonardo de Oliveira Martins, and David Posada. Simphy: phylogenomic simulation of gene, locus, and species trees. *Systematic biology*, 65(2):334-344, 2016.

37. Marina Marcet-Houben and Toni Gabaldón. Beyond the whole-genome duplication: phylogenetic evidence for an ancient interspecies hybridization in the baker's yeast lineage. *PLoS biology*, 13(8):e1002220, 2015.

38. Vacharapat Mettanant and Jittat Fakcharoenphol. A linear-time algorithm for the multiple gene duplication problem. In *The 12th National Computer Science and Engineering Conference (NCSEC)*, pages 198-203, 2008.

39. Vincent Moulton and Mike Steel. Retractions of finite distance functions onto tree metrics. *Discrete Applied Mathematics*, 91(1-3):215-233, 1999.

40. S. Ohno. *Evolution by Gene Duplication*. Springer-Verlag, 1970.

41. Sarah P Otto. The evolutionary consequences of polyploidy. *Cell*, 131(3):452-462, 2007.

42. Roderic DM Page. Maps between trees and cladistic analysis of historical associations among genes, organisms, and areas. *Systematic biology*, 43(1):58-77, 1994.

43. Roderic DM Page and JA Cotton. Vertebrate phylogenomics: reconciled trees and gene duplications. In *Biocomputing 2002*, pages 536-547. World Scientific, 2001.

44. Jarosław Paszek and Paweł Górecki. Efficient algorithms for genomic duplication models. *IEEE/ACM transactions on computational biology and bioinformatics*, 15(5):1515-1524, 2017.

45. Charles-Elie Rabier, Tram Ta, and Cécile Ané. Detecting and locating whole genome duplications on a phylogeny: a probabilistic approach. *Molecular biology and evolution*, 31(3):750-762, 2014.

46. Jacob L Steenwyk and Nicole King. The promise and pitfalls of synteny in phylogenomics. *Plos Biology*, 22(5):e3002632, 2024.

47. Ikram Ullah, Joel Sjöstrand, Peter Andersson, Bengt Sennblad, and Jens Lagergren. Integrating sequence evolution into probabilistic orthology analysis. *Systematic biology*, 64(6):969-982, 2015.

48. Kevin Vanneste, Yves Van de Peer, and Steven Maere. Inference of genome duplications from age distributions revisited. *Molecular biology and evolution*, 30(1):177-190, 2013.

49. Kenneth H Wolfe. Origin of the yeast whole-genome duplication. *PLoS biology*, 13(8):e1002221, 2015.
50. Troy E Wood, Naoki Takebayashi, Michael S Barker, Itay Mayrose, Philip B Green-spoon, and Loren H Rieseberg. The frequency of polyploid speciation in vascular plants. *Proceedings of the national Academy of sciences*, 106(33):13875-13879, 2009.

51. Louxin Zhang. On a mirkin-muchnik-smith conjecture for comparing molecular phylogenies. *Journal of Computational Biology*, 4(2):177-187, 1997.