Home | About | Journals | Submit | Contact Us | Français |

**|**Algorithms Mol Biol**|**v.12; 2017**|**PMC5349084

Formats

Article sections

- Abstract
- Background
- Problem statement and preliminaries
- NP-hardness
- APX-hardness of the DLC parsimony problem
- Conclusion
- References

Authors

Related links

Algorithms Mol Biol. 2017; 12: 6.

Published online 2017 March 14. doi: 10.1186/s13015-017-0098-8

PMCID: PMC5349084

Daniel Bork,^{1,}^{2} Ricson Cheng,^{3} Jincheng Wang,^{1} Jean Sung,^{1} and Ran Libeskind-Hadas^{}^{1}

Daniel Bork, Email: ude.cmh.g@krobd.

Received 2016 August 22; Accepted 2017 February 5.

Copyright © The Author(s) 2017

Phylogenetic tree reconciliation is a widely-used method for inferring the evolutionary histories of genes and species. In the duplication-loss-coalescence (DLC) model, we seek a reconciliation that explains the incongruence between a gene and species tree using gene duplication, loss, and deep coalescence events. In the maximum parsimony framework, costs are associated with these event types and a reconciliation is sought that minimizes the total cost of the events required to map the gene tree onto the species tree.

We show that this problem is NP-hard even for the special case of minimizing the number of duplications. We then show that the problem is APX-hard when both duplications and losses are considered, implying that no polynomial-time approximation scheme can exist for the problem unless P = NP.

These intractability results are likely to guide future research on algorithmic aspects of the DLC-reconciliation problem.

Phylogenetic tree reconciliation is a fundamental technique in the study of the evolutionary relationships of genes and species. Given a gene tree, a species tree, and the association between their leaves, we seek to explain the incongruence between the two trees using a set of evolutionary events. In the widely-used DL model, duplication and loss events are considered, while the DTL model considers horizontal transfers as well. Although these models can explain paralogous gene families, they do not address population effects. In contrast, coalescent models [1] can explain population effects but implicitly assume that all genes are orthologs. Recently, a new duplication-loss-coalescence (DLC) model has been proposed that combines the duplication-loss tree reconciliation model with a coalescent model. This DLC model has been shown to have higher accuracy of reconstructing evolutionary events than the DL model alone [2, 3].

Reconciliation is often performed using a maximum parsimony formulation in which each type of event in the model has an associated non-negative cost and the objective is to find a reconciliation of minimum total cost. Wu et al. [3] gave the first maximum parsimony algorithm for the DLC reconciliation problem. That algorithm has worst-case exponential time, leaving open the question of whether the problem can be solved in polynomial time.

In this paper, we show that the DLC parsimony problem is NP-hard and, further, has no polynomial-time approximation scheme (PTAS) unless P = NP. Specifically, we show that:

- The DLC parsimony problem is NP-hard even when only seeking to minimize the number of duplications (i.e., loss and coalescence events have zero cost). However, the problem of minimizing duplications alone can be approximated using a PTAS for the multicut problem [4].
- The DLC parsimony problem is APX-hard even when only duplications and losses are considered (i.e., coalescence events have zero cost), which implies that no PTAS exists for this problem unless P = NP.

Just as complexity results for DTL parsimony [5–7] guided the direction of algorithmic research on that problem, these results serve to guide future work on algorithms and heuristics for the DLC parsimony problem.

Finally, we note that while the DLC reconciliation problem considers duplications and losses, those events are treated differently from duplications and losses in the DL and DTL models due to the introduction of explicit gene loci in the DLC model. Thus, the complexity results that we offer here are not directly related to those for the DL and DTL models. The interested reader is referred to [5–7] for discussions of the DL and DTL models and known results about their computational complexity.

This section provides notation, definitions, and basic results that will be used throughout the paper.

We begin with notation and definitions adapted from Wu et al. [3]. A *tree* is a rooted binary tree *T* = (*V*(*T*), *E*(*T*)) where *V*(*T*) denotes the set of nodes and *E*(*T*) denotes the set of directed edges, also called *branches*. An edge terminating at a leaf node is called a *terminal edge*. Denote by *L*(*T*) ⊂ *V*(*T*) the set of leaves of *T*, *I*(*T*) = *V*(*T*)\*L*(*T*) the set of internal nodes, and *r*(*T*) ∈ *I*(*T*) the root node. In a binary tree, leaves correspond to extant taxa whereas internal nodes correspond to ancestral taxa.

Denote by *c*(*v*) the set of children of *v*, *p*(*v*) the parent of *v*, and *e*(*v*) the directed edge (*p*(*v*), *v*). The partial orders ≤_{T} and ≥_{T} on *V*(*T*) are defined by *u*≤_{T}*v* if *u* is on the path from *r*(*T*) to *v* and *u*≥_{T}*v* if *v* is on the path from *r*(*T*) to *u*. Note that as required by a partial ordering, ≤_{T} and ≥_{T} are reflexive (*u*≤_{T}*u* and *u*≥_{T}*u*). If *u*≤_{T}*v* and *u* ≠ *v* then *u* is said to be an *ancestor* of *v* and *v* is a *descendant* of *u*. The *distance* from a node *u* to *v*, where *u*≤_{T}*v*, is the length of the shortest path from *u* to *v*. The *least common ancestor* of nodes *u*, *v*, denoted *l**c**a*(*u*, *v*), is the node *w* of maximum distance from *r*(*T*) such that *w*≤_{T}*u* and *w*≤_{T}*v*. For two nodes *u*, *v* ∈ *T*, we say that an edge *e*
*separates*
*u* and *v* if *e* is either on the path from *l**c**a*(*u*, *v*) to *u* or on the path from *l**c**a*(*u*, *v*) to *v*. For convenience, we also use *l**c**a* as shorthand for the term “least common ancestor” when the context is clear.

A *leaf map* is a function *L**e*:*L*(*G*) → *L*(*S*) that associates each leaf in the gene tree with the leaf in the species tree in which that gene is found. This function need not be one-to-one nor onto; gene tree leaves that map onto the same species tree leaf correspond to paralogous genes. The *labeled coalescent tree*, defined below, formalizes the notion of a reconciliation in the DLC model.

(*Labeled Coalescent Tree*) Given gene tree *G*, species tree *S*, and leaf map *L**e*:*L*(*G*) → *L*(*S*), a *labeled coalescent tree (LCT)* for (*G*, *S*, *L**e*) is a tuple (ℳ, 𝕃, ℒ) where:

- ℳ:
*V*(*G*) →*V*(*S*) is a**species map**which maps each node of*G*to a node of*S*; - 𝕃 is a finite set, called the
**locus set**of loci that have evolved within the gene family; - ℒ:
*V*(*G*) → 𝕃 is a**locus map**that maps each node of*G*to a locus in 𝕃

subject to the following constraints:

- If
*g*∈*L*(*G*), then ℳ(*g*) =*L**e*(*g*); - If
*g*∈*I*(*G*), then for*g*^{′}∈*c*(*g*), ℳ(*g*)≤_{S}ℳ(*g*^{′}); - For
*g*,*g*^{′}∈*L*(*G*) where*g*≠*g*^{′}, if*L**e*(*g*) =*L**e*(*g*^{′}) then ℒ(*g*) ≠ ℒ(*g*^{′}); - For
*ℓ*∈ 𝕃, there exists*g*∈*V*(*G*) s.t. ℒ(*g*) =*ℓ*; - For
*ℓ*∈ 𝕃, let*N*(*ℓ*) = {*g*|*g*∈*V*(*G*);*g*≠*r*(*G*);ℒ(*g*) =*ℓ*;ℒ(*p*(*g*)) ≠*ℓ*}. Then |*N*(*ℓ*)| ≤ 1, where equality holds everywhere except for*ℓ*= ℒ(*r*(*g*)).

Constraint 1 asserts that the species map ℳ extends the leaf map *Le*; constraint 2 asserts that a gene node is mapped to either the same node or an ancestor of each of its children; constraint 3 asserts that since extant gene nodes (leaves) mapped to the same extant species (leaves) are paralogs, they must be mapped to different loci; constraint 4 asserts that the locus set only includes a locus if at least one gene uses that locus; and constraint 5 asserts that each locus is created only once.^{1}

A gene node *g* is said to be a *speciation node* with respect to map ℳ if for each child *g*^{′} ∈ *c*(*g*),
ℳ(*g*) ≠ ℳ(*g*^{′}). Since a branch of the gene tree may span multiple branches of the species tree for a given map ℳ, *implied speciation nodes* are added as follows: For each non-root internal node *g* ∈ *I*(*G*)\{*r*(*G*)} such that either (1) *p*(ℳ(*g*)) ≠ ℳ(*p*(*g*)) or (2) *p*(*g*) is not a speciation node and ℳ(*g*) ≠ ℳ(*p*(*g*)), introduce a new node *h* and replace edge (*p*(*g*), *g*) with the pair of edges (*p*(*g*), *h*) and (*h*, *g*) and define ℳ(*h*) = *p*(ℳ(*g*)). This process is repeated until there exists no node *g* that satisfies the conditions above. Wu et al. stipulate that the species map ℳ is defined first, then implicit speciation nodes are added as required, and finally the locus map is defined on the vertices of the gene tree, which now includes any implied speciation nodes.

The set of gene nodes mapped to a given species node *s* is denoted *n**o**d**e**s*(*s*) = {*g*|*g* ∈ *V*(*G*);ℳ(*g*) = *s*}; *b**o**t**t**o**m**s*(*s*) = {*g*|*g* ∈ *n**o**d**e**s*(*s*);*g* ∈ *L*(*G*) ∨ ∀ *g*^{′} ∈ *c*(*g*), *g*^{′} ∉ *n**o**d**e**s*(*s*)} is the subset of *n**o**d**e**s*(*s*) whose children are mapped to descendants of *s*; and *t**o**p**s*(*s*) = *b**o**t**t**o**m**s*(*p*(*s*)).^{2} For any set *A* ⊂ *V*(*G*), let *l**o**c**i*(*A*) = {*ℓ*|∃ *g* ∈ *A* s.t. *ℓ* = ℒ(*g*)} denote the set of loci present on all genes in set *A*.

Next, Wu et al. define duplication and loss events. A duplication event corresponds to the creation of a new locus while a loss event corresponds to a locus that is present at either the top of a species branch, or created via a duplication within the species branch, but no longer present at the bottom of the species branch. More precisely, these events are defined as follows:

(*Duplication and Loss Events*) Let *G*, *S*, and *L**e* denote a gene tree, species tree, and leaf map *L**e*:*L*(*G*) → *L*(*S*), respectively, and let (ℳ, 𝕃, ℒ) be a LCT for (*G*, *S*, *L**e*).

**Duplication events:**Let*g*∈*V*(*G*),*g*≠*r*(*G*). If ℒ(*g*) ≠ ℒ(*p*(*g*)) then*g*induces a*duplication event*on the edge*e*(*g*) = (*p*(*g*),*g*).**Loss events:**Let*s*∈*V*(*S*),*s*≠*r*(*S*). A locus*ℓ*∈ 𝕃 induces a*loss event*on edge*e*(*s*) = (*p*(*s*),*s*) if*ℓ*∈*l**o**c**i*(*t**o**p**s*(*s*) ∪*n**o**d**e**s*(*s*))\*l**o**c**i*(*b**o**t**t**o**m**s*(*s*)).

Figure 1 shows a (a) gene tree, (b) species tree, and (c) a species map and locus map with a duplication event. Figure 2 shows a subtree of a gene tree and a subtree of a species tree with the species and locus maps inducing multiple loss events.

(*Reconciliation Cost*) Given gene tree *G*, species tree *S*, leaf map *L**e*:*L*(*G*) → *L*(*S*), and non-negative real number costs *C*_{d} and *C*_{ℓ} for duplication and loss events, respectively, the *cost* of a LCT for (*G*, *S*, *L**e*) with *d* duplications events and *ℓ* loss events is *d**C*_{d} + *ℓ**C*_{ℓ}.

(*DCL Optimization Problem (DCLOP)*) Given gene tree *G*, species tree *S*, leaf map *L**e*:*L*(*G*) → *L*(*S*), and non-negative costs *C*_{d} and *C*_{ℓ} for duplication and loss events, find a LCT for (*G*, *S*, *L**e*) of minimum cost.

(*DCL Decision Problem (DCLDP)*) Given gene tree *G*, species tree *S*, leaf map *L**e*:*L*(*G*) → *L*(*S*), non-negative costs *C*_{d} and *C*_{ℓ} for duplication and loss events, and non-negative decision parameter *k*, does there exist a LCT for (*G*, *S*, *L**e*) of cost at most *k*?

Duplication events are determined entirely by the locus map ℒ whereas loss events depend on both the species map and the locus map. For convenience in our subsequent analyses, we give an alternate characterization of the locus map and prove its equivalence with the original definition.

(*Duplication Placement*) Given gene tree *G*, species tree *S*, and leaf map *L**e*:*L*(*G*) → *L*(*S*), a *duplication placement* is a subset *D* of the edges of *G* such that for every pair of leaves *g*, *g*^{′} ∈ *L*(*G*) where *g* ≠ *g*^{′}, if *L**e*(*g*) = *L**e*(*g*^{′}) then *D* contains an edge that separates *g* and *g*^{′}.

*Given gene tree G, species tree S, and leaf map *
*L**e*:*L*(*G*) → *L*(*S*),* for every locus map*
ℒ
* in a LCT inducing d duplication events, there exists a duplication placement D such that*
|*D*| = *d*.* Conversely, for every duplication placement*
*D*
* such that*
|*D*| = *d*,* there exists a locus map*
ℒ
* that induces exactly d duplications.*

Let ℒ be a locus map for (*G*, *S*, *L**e*) and define *D* to be the set of all edges *e*(*g*) = (*p*(*g*), *g*), *g* ∈ *V*(*G*), such that there is a duplication on edge *e*(*g*). By definition, |*D*| is the number of duplication events induced by ℒ. To show that *D* is a duplication placement, consider any pair of leaves *g*, *g*^{′} ∈ *L*(*G*) where *g* ≠ *g*^{′} and *L**e*(*g*) = *L**e*(*g*^{′}). By Definition 1 (3), ℒ(*g*) ≠ ℒ(*g*^{′}). Let *P* denote the path from *l**c**a*(*g*, *g*^{′}) to *g* and let *P*^{′} denote the path from *l**c**a*(*g*, *g*^{′}) to *g*^{′}. There must exist some edge (*p*(*u*), *u*) in *P* ∪ *P*^{′} such that ℒ(*u*) ≠ ℒ(*p*(*u*)) since otherwise every node in *P* and *P*^{′} is mapped to the same locus, contradicting the assumption that ℒ(*g*) ≠ ℒ(*g*^{′}). Therefore, there is necessarily a duplication event on an edge in *P* ∪ *P*^{′}; this edges separates *g* and *g*^{′} and thus *D* is a duplication placement.

Conversely, let *D* be a duplication placement and consider the set *S*(*D*) = {*G*_{1}, …, *G*_{|D|+1}} comprising the |*D*| + 1 subgraphs of *G* induced by the removal of the edges of *D* from *G*. Note that *S*(*D*) partitions the nodes *V*(*G*). Let 𝕃 = {1, …, |*D*| + 1} and let ℒ map all nodes in *G*_{i} to *i* ∈ 𝕃. It follows directly that this satisfies the requirements of a locus map in Definition 1 (3), (4), (5). □

Henceforth, we use locus maps and duplication placements interchangeably. When defining a duplication placement *D*, we say that a duplication is *placed* on an edge (*u*, *v*) to mean that edge (*u*, *v*) is included in the set *D*. We say that a duplication is *placed between* two leaves *g* and *g*^{′} to mean that there is a duplication placed on some edge that separates *g* and *g*^{′}.

Our reductions will be from 3SAT [8]: Given *m* Boolean variables *x*_{1}, …, *x*_{m} and *n* clauses *C*_{1}, …, *C*_{n} where each clause is the disjunction of exactly three literals over the given set of variables, we wish to determine whether there exists a valuation of the variables such that all clauses are satisfied. Without loss of generality, each literal occurs at most once per clause. In addition, the literals in the clauses are assumed to be ordered so that we may uniquely refer to the* h*th literal of each clause, 1 ≤ *h* ≤ 3. Since the clauses are ordered, we may also uniquely refer to the* q*th occurrence of a literal *x*_{i} (or ${\overline{x}}_{i}$) in the 3SAT instance. Finally, without loss of generality, we assume that no clause contains both a literal and its negation (since such clauses are trivially satisfied by every valuation and can thus be removed).

We show that DLCDP is NP-hard, even when loss events have cost zero, by a reduction from 3SAT. To provide intuition, we begin with a small example of the reduction and sketch the proof of correctness. Afterwards, we formalize the reduction and prove its correctness.

Figure 3 shows the construction for the 3SAT instance comprising a single clause, $({x}_{1}\vee {\overline{x}}_{2}\vee {x}_{3})$. We construct a gene tree with a single clause gadget on the left and one variable gadget for each of *x*_{1}, *x*_{2}, and *x*_{3} on the right. The variable gadget for variable *x*_{i} is a subtree rooted at node *x*_{i}. That node has a true branch and a false branch, corresponding to setting that variable true or false, respectively. The nodes at the end of the true and false branches each have two children, resulting in four leaves for each variable gadget. (In general, variable gadgets can be larger than this, with size dependent on the number of clauses in which *x*_{i} appears). One leaf on the true side and one leaf on the false side of the variable gadget get mapped to the same species tree leaf, as represented by the dashed rectangles at the bottom right of Fig. 3 and labeled 1, 2, and 3 for *x*_{1}, *x*_{2}, and *x*_{3}, respectively. Since each of these pairs of leaves are paralogs mapped to the same species leaf, there must be a duplication placed between them. As we shall see, our construction will force there to be a duplication on exactly one of the true or false branches incident on each *x*_{i}, corresponding to setting each variable to true or false, respectively.

Next, the gadget for clause 1 has five internal nodes (this is true in general, not just in this small example). The three important internal nodes are *λ*_{1,1}, *λ*_{2,1}, *λ*_{3,1} corresponding to the first, second, and third literals in clause 1. Each of these internal nodes has one leaf child that is mapped to a shared species leaf, as indicated in the dashed rectangle at the bottom left labeled *A*. Since the first literal in clause 1 is *x*_{1}, clause node *λ*_{1,1} and the true node in the variable gadget for *x*_{1} each have a leaf child that is mapped to the same species node labeled *B* in the figure. Similarly, since the second literal of clause 1 is ${\overline{x}}_{2}$, clause node *λ*_{2,1} and the false node in the variable gadget for *x*_{2} each have a leaf child that is mapped to the same species node labeled *C* in the figure. Finally, *λ*_{3,1} and the true node in the *x*_{3} gadget have leaves on a shared species node *D*. All remaining leaves in the variable gadgets are mapped to their own individual unshared species leaves, placing no constraints on their locus mappings.

We set the cost of duplication events, *C*_{d}, to 1 and the cost of loss events, *C*_{ℓ}, to 0. We set the decision parameter in this example to 5 which will force two duplications to be used in the clause gadget and one to be used in each of the three variable gadgets in a way that corresponds to choosing a valuation for the three variables (in general, the decision parameter for the number of duplications will be equal to the number of variables plus twice the number of clauses).

As noted earlier, the variable gadget leaves mapped to species 1, 2, and 3 require that there be at least one duplication placed within each variable gadget. Similarly, the three clause gadget leaves mapped to species *A* are paralogs and imply that there must be two duplications placed in the clause gadget rooted at *δ*_{1}. Thus, in order to use no more than the five given duplications, there must be exactly one duplication placed in each variable gadget and exactly two duplications placed in the clause gadget. Moreover, without loss of generality, we can assume that duplications do not occur on edges terminating at leaves, since such duplications can be pushed up one level in the tree without violating any of the species map constraints.

We now sketch how the proof of correctness will proceed. First, assume that there is a satisfying assignment for the 3SAT instance (for example, *x*_{1} = true, *x*_{2} = true, *x*_{3} = false). We place duplications on the corresponding edges in the variable gadgets. This satisfies the requirement that there exists a duplication placed between each pair of leaves associated with species 1, 2, and 3. Since, in our valuation, *x*_{1} = true satisfies the clause, we choose *not* to place a duplication on the edge terminating at *λ*_{1,1} in the clause gadget, instead placing duplications on the two edges terminating at *λ*_{2,1} and *λ*_{3,1}. This satisfies the requirement that a duplication is placed between each pair of the three clause leaves associated with species *A*. Moreover, the two leaves associated with species *B* have a duplication between them due to the duplication on *x*_{1}’s true edge and the leaves associated with groups *C* and *D* have duplications between them due to the duplications placed on the edges terminating at *λ*_{2,1} and *λ*_{3,1}.

To prove the converse direction, we assume a solution to the constructed DLCDP instance; as noted above, this implies that there exists one duplication placed in each variable gadget and two in the clause gadget. At least one duplication must be placed in the subtree rooted at ${\mathit{\delta}}_{1}^{\prime}$, as it is the *l**c**a* of two leaves in group *A*. Therefore, only one of the three remaining internal edges in the subtree rooted at *δ*_{1} can contain a duplication. Thus, at least one of the pairs of leaves mapped to species *B*, *C*, or *D* cannot be separated by a duplication placed inside the clause gadget and thus must be separated by a duplication placed inside a variable gadget. Consider, for example, the case that the pair of leaves in group *B* is separated by an edge in a variable gadget. By construction, that duplication must then occur on the true side of the *x*_{1} gadget, which corresponds to setting *x*_{1} to be true in the valuation which, in turn, satisfies this 3SAT instance.

Given a 3SAT instance with *m* variables *x*_{1}, *x*_{2}, …, *x*_{m} and *n* clauses *C*_{1}, *C*_{2}, …, *C*_{n}, we construct an instance of DLCDP comprising *m* variable gadgets and *n* clause gadgets.

A variable gadget for variable *x*_{i}, shown in Fig. 4, is a binary tree with root node *α*_{i} which, in turn, has two children *β*_{i} and ${\overline{\mathit{\beta}}}_{i}$ which are roots of two subtrees. Node *β*_{i} has two children: a leaf *y*_{i} and an internal node *β*_{i,1}. Each node *β*_{i,k} has two children: a leaf *y*_{i,k} and an internal node *β*_{i,k+1}, 1 ≤ *k* < *n* - 1. Node *β*_{i,n-1} has two children: leaves *y*_{i,n-1} and *y*_{i,n}. Similarly, node ${\overline{\mathit{\beta}}}_{i}$ has a child labeled ${\overline{y}}_{i}$ and another child ${\overline{\mathit{\beta}}}_{i,1}$. Each node ${\overline{\mathit{\beta}}}_{i,k}$ has a child ${\overline{y}}_{i,k}$ and a child ${\overline{\mathit{\beta}}}_{i,k+1}$, 1 ≤ *k* < *n* - 1. Node ${\overline{\mathit{\beta}}}_{i,n-1}$ has children ${\overline{y}}_{i,n-1}$ and ${\overline{y}}_{i,n}$.

A clause gadget for clause *C*_{j}, shown in Fig. 5, is a binary tree rooted at node *δ*_{j} which in turn has children ${\mathit{\delta}}_{j}^{\prime}$ and *λ*_{3,j}. Node ${\mathit{\delta}}_{j}^{\prime}$ has children *λ*_{1,j} and *λ*_{2,j}. Finally, each node *λ*_{h,j} has two leaf children, *k*_{h,j} and ${k}_{h,j}^{\prime}$, 1 ≤ *h* ≤ 3.

The gene tree is constructed by assembling *m* variable gadgets and *n* clause gadgets into a single binary tree. Specifically, the gene tree is constructed from an arbitrary binary tree with *m* + *n* leaves. The first *m* leaves become the roots of *m* variable gadgets corresponding to variables *x*_{1}, …, *x*_{m} while the remaining *n* leaves become the roots of *n* clause gadgets corresponding to clauses *C*_{1}, …, *C*_{n}.

The species tree is an arbitrary binary tree with 2*m**n* + *m* + *n* leaves labeled 1, …, 2*m**n* + *m* + *n*.

We define *L**e*:*L*(*G*) → *L*(*S*) as follows:

- $Le({y}_{i})=Le({\overline{y}}_{i})=i$, 1 ≤
*i*≤*m*. *L**e*(*k*_{1,j}) =*L**e*(*k*_{2,j}) =*L**e*(*k*_{3,j}) =*m*+*j*, 1 ≤*j*≤*n*,- For each
*x*_{i}appearing as the*h*-th literal in clause*C*_{j}, $Le({k}_{h,j}^{\prime})=Le({y}_{i,j})=m+n+3(j-1)+h$, - For each ${\overline{x}}_{i}$ appearing as the
*h*-th literal in clause*C*_{j}, $Le({k}_{h,j}^{\prime})=Le({\overline{y}}_{i,j})=m+n+3(j-1)+h$, - Every leaf
*g*∈*L*(*G*) whose mapping is not specified above is mapped to a unique species leaf*s*∈*L*(*S*) such no other gene leaf is mapped to*s*.

Note that steps 1 through 4 of this leaf map define the mapping of gene tree leaves onto species leaves 1, …, *m* + 4*n*. By construction, after these first four steps in the leaf map, there remain 2*m**n* - 3*n* gene tree leaves that are not yet mapped and (2*m**n* + *m* + *n*) - (*m* + 4*n*) = 2*m**n* - 3*n* species tree leaves that are not yet mapped onto. Thus, in step 5 of the leaf map, every gene tree leaf whose mapping was not established in parts 1 through 4 can be mapped to a unique species tree leaf.

We set the cost of a duplication event to be 1 and all other event costs to be 0. The decision parameter is 2*n* + *m*, meaning in this case that we seek a reconciliation with at most 2*n* + *m* duplications. It is easily seen that this reduction can be performed in time polynomial in the size of the given 3SAT instance.

We first show that the existence of a satisfying valuation to a given 3SAT instance implies that the corresponding DLCDP instance is true. We prove this by constructing a duplication placement *D* of size 2*n* + *m* as follows: For each literal *x*_{i}, place a duplication on edge *e*(*β*_{i}) = (*α*_{i}, *β*_{i}) if *x*_{i} is true in the valuation and place a duplication on edge $e({\overline{\mathit{\beta}}}_{i})=({\mathit{\alpha}}_{i},{\overline{\mathit{\beta}}}_{i})$ if *x*_{i} is false. This ensures that all pairs of leaves *y*_{i} and ${\overline{y}}_{i}$, 1 ≤ *i* ≤ *m*, are separated by an edge in *D* as required by part 1 of the leaf map above.

Next, consider an arbitrary clause *C*_{j} and one of the literals *x*_{i} whose true valuation satisfies *C*_{j} (the case that the literal is ${\overline{x}}_{i}$ is analogous). Without loss of generality, assume that *x*_{i} is the first literal in clause *C*_{j} (the case that the literal is the second or third literal in the clause is analogous). The placement of a duplication on edge *e*(*β*_{i}) ensures that leaves ${k}_{1,j}^{\prime}$ and *y*_{i,j} are separated by an edge in *D* as required by part 3 (analogously, part 4) of the leaf map. Next, we place duplications on the edges *e*(*λ*_{2,j}) and *e*(*λ*_{3,j}) in the clause gadget for *C*_{j}. This separates all leaves in part 2 of the leaf map and separates the remaining leaves in parts 3 and 4. Part 5 of the leaf map has no leaves requiring separation by *D*.

Since all of the duplication requirements implied by the leaf map are satisfied by this duplication placement and it uses exactly *k* = 2*n* + *m* duplications, this is a solution to the constructed DLCDP instance.

Given a solution to the DLCDP instance, we construct a satisfying valuation for the corresponding 3SAT instance. Because part 1 of the leaf map associates each pair *y*_{i} and ${\overline{y}}_{i}$, 1 ≤ *i* ≤ *m*, with the same species node, each such pair must be separated by an edge in *D*. By construction, each such pair must be separated by a distinct edge in the variable gadget for *x*_{i} which is either an edge on the path from *α*_{i} to *y*_{i} or on the path from *α*_{i} to ${\overline{y}}_{i}$. Separating all such pairs therefore requires *m* edges in *D*.

For each clause *C*_{j}, 1 ≤ *j* ≤ *n*, the leaves *k*_{1,j}, *k*_{2,j}, and *k*_{3,j} are mapped to the same species leaf by part 2 of the leaf map. Therefore, each pair of those leaves must be separated by an edge in *D* and, by the construction of the clause gadget, this requires two edges in each clause gadget and thus a total of 2*n* additional edges in *D*.

Thus, all *k* = 2*n* + *m* are required to satisfy parts 1 and 2 of the leaf map, with exactly *m* edges selected from the variable gadgets and exactly 2*n* edges from the clause gadgets.

We construct a valuation of the boolean variables in the 3SAT instance as follows: for 1 ≤ *i* ≤ *m*, set *x*_{i} to true if there is a duplication placed on some edge on the path from *α*_{i} to *y*_{i}, and set *x*_{i} to false if there is a duplication along the path from *α*_{i} to ${\overline{y}}_{i}$.

Consider an arbitrary clause *C*_{j} and its corresponding gadget in the gene tree. Part 2 of the leaf map requires that there be an edge in *D* separating each pair of of *k*_{1,j}, *k*_{2,j}, and *k*_{3,j}, but, as noted above, only two edges of *D* are placed within that clause gadget. Since ${\mathit{\delta}}_{j}^{\prime}$ is the lca of *k*_{1,j} and *k*_{2,j}, at least one duplication must be placed in the subtree rooted at ${\mathit{\delta}}_{j}^{\prime}$. Therefore, at least one of the three paths from *δ*_{j} to ${k}_{1,j}^{\prime}$, ${k}_{2,j}^{\prime}$, and ${k}_{3,j}^{\prime}$ does not contain an edge in *D*. Without loss of generality, assume that the path from *δ*_{j} to ${k}_{1,j}^{\prime}$ does not contain an edge in *D* and let *x*_{i} be the first literal in clause *C*_{j} (the argument is analogous if *x*_{i} is the second or third literal of the clause). Then, by part 3 (analogously, part 4) of the leaf map, ${k}_{1,j}^{\prime}$ and *y*_{i,j} must be separated by an edge in *D*. Since this edge occurs in the variable gadget for *x*_{i}, by the observations above it must occur on the path from *α*_{i} to *y*_{i}, resulting in setting *x*_{i} = true and thereby satisfying clause *C*_{j}.

Thus, all clauses are satisfied and the 3SAT instance is satisfiable. □

When only the duplication cost is considered, the DLC optimization problem, DLCOP, can be approximated arbitrarily well using the polynomial-time approximation scheme (PTAS) for Multicut in binary trees [4] since duplications correspond exactly to removed edges in the Multicut problem. However, we now show that DLCOP has no PTAS in general, unless P = NP. Specifically, we show that DLCOP is APX-hard when duplications and losses are considered. We establish this result by a polynomial-time reduction from max3sat(b) which comprises a Boolean formula in 3-CNF form in which each variable appears at most *B* times in the clauses. Arora [9] showed that, for some *ϵ*, 0 < *ϵ* < 1, there exists a constant value of *B* (*B* = 13) and a polynomial-time reduction from any NP-complete problem Π to max3sat(b) that maps *yes* instances of Π to satisfiable instances of max3sat(b) and *no* instances of Π to instances of max3sat(b) in which less than 1 - *ϵ* of the total number of clauses are satisfiable.

Our reduction maps an instance of max3sat(b) with *n* clauses (for sufficiently large values of *n*) to an instance of DLCOP and a parameter *b* such that the optimal solution to the DLCOP instance is less than *b* if the max3sat(b) instance is satisfiable and more than (1 + *α*)*b* if at most (1 - *ϵ*)*n* clauses can be satisfied, for some constant *α* > 0. If a polynomial-time (1 + *α*)-approximation algorithm exists for DLCOP, we can apply our gap-preserving reduction to generate a DLCOP instance from the max3sat(b) instance and then run the putative approximation algorithm to distinguish between satisfiable and (1 - *ϵ*)-satisfiable instances of max3sat(b). Thus, the existence of a (1 + *α*)-approximation algorithm for DLC implies that *P* = *N**P*, and the approximation-hardness of DLCOP follows.

Given an instance of max3sat(b) comprising *m* variables and *n* clauses, we construct an instance of DLCOP comprising a gene tree, a species tree, a leaf map, and event costs. The reduction is based on the NP-hardness reduction in the previous section but introduces more complex gadgetry and uses nonzero cost for loss events.

An *ℓ*
*-thorn* gadget, depicted in Fig. 6, is a binary tree with *ℓ* leaves constructed as follows: let the root node be *u*_{1}. Each node *u*_{i} has two children: internal node *u*_{i+1} and leaf *t*_{i}, 1 ≤ *i* ≤ *ℓ* - 2. Node *u*_{ℓ-1} has two leaf children *t*_{ℓ-1} and *t*_{ℓ}. Leaf *t*_{ℓ} is denoted the *end tip* of the thorn gadget.

Let *B*(*i*) and $\overline{B}(i)$ denote the number of occurrences of literals *x*_{i} and ${\overline{x}}_{i}$, respectively. The variable gadget for variable *x*_{i}, illustrated in Fig. 7, consists of a root node, *α*_{i}, and two subtrees, one for each of the two literals of this variable. The left subtree has root *β*_{i}, with two children: Internal node ${\mathit{\beta}}_{i}^{\prime}$ and leaf *y*_{i}. In turn, ${\mathit{\beta}}_{i}^{\prime}$ has two children: Internal node *β*_{i,1} and leaf ${y}_{i}^{\prime}$. Each node *β*_{i,q}, 1 ≤ *q* ≤ *B*(*i*) - 2, has a child *β*_{i,q+1} and a second child which is the root of a (*n*^{2} - 1)-thorn gadget with end tip *y*_{i,q}. Node *β*_{i,B(i)-1} has two children, each of which is the root of a (*n*^{2} - 1)-thorn gadget. The end tips of these thorn gadgets are labeled *y*_{i,B(i)-1} and *y*_{i,B(i)}. This construction introduces a distinct (*n*^{2} - 1)-thorn gadget for each occurrence of *x*_{i} in the 3SAT instance. We refer to the thorn gadget terminating at end tip *y*_{i,q} as *the thorn gadget for the*
* q*th *occurrence of*
*x*_{i}. The right subtree of *α*_{i}, representing literal ${\overline{x}}_{i}$, is symmetric to the left subtree, but with *β*_{i} and ${\mathit{\beta}}_{i}^{\prime}$ replaced with ${\overline{\mathit{\beta}}}_{i}$ and ${\overline{\mathit{\beta}}}_{i}^{\prime}$, respectively, each *β*_{i,j} replaced by ${\overline{\mathit{\beta}}}_{i,j}^{\prime}$, and each *y*_{i,j} replaced by ${\overline{y}}_{i,j}$. This construction introduces a distinct (*n*^{2} - 1)-thorn gadget for each clause containing ${\overline{x}}_{i}$. We refer to the thorn gadget terminating at end tip ${\overline{y}}_{i,q}$ as *the thorn gadget for the*
* q*th *occurrence of*
${\overline{x}}_{i}$.

A clause gadget corresponding to clause *C*_{j}, shown in Fig. 8, consists of root node *δ*_{j} with children ${\mathit{\delta}}_{j}^{\prime}$ and *λ*_{3,j}. Node ${\mathit{\delta}}_{j}^{\prime}$ has two children *λ*_{1,j} and *λ*_{2,j}. Each node *λ*_{h,j}, 1 ≤ *h* ≤ 3, is the root of a tree with two children, a leaf *k*_{h,j} and a node ${\mathit{\lambda}}_{h,j}^{\prime}$, which in turn has two leaf children ${k}_{h,j}^{\prime}$ and ${k}_{h,j}^{\prime \prime}$.

The gene tree *G* is constructed as follows: the root of the gene tree is a node *g*_{0} with children *g*_{1} and *g*_{2}. Node *g*_{1} is the root of a (3*n* - *m* + 1)-thorn gadget. Node *g*_{2} is the root of an arbitrary binary subtree with *n* + *m* leaves. Each of the first *n* of those leaves becomes the root of a clause gadget for clauses *C*_{1}, …, *C*_{n} and the remaining *m* leaves become the roots of *m* variable gadgets for variables *x*_{1}, …, *x*_{m}.

The species tree, shown in Fig. 9, is rooted at node *ρ*_{0} and is constructed from a path *ρ*_{0}, …, *ρ*_{2m} followed by ${\mathit{\sigma}}_{1},{\mathit{\sigma}}_{1}^{\prime},\dots ,{\mathit{\sigma}}_{n},{\mathit{\sigma}}_{n}^{\prime}$, and finally *τ*_{1,1}, *τ*_{2,1}, *τ*_{3,1}, …, *τ*_{1,n}, *τ*_{2,n}, *τ*_{3,n}. This path is henceforth referred to as the *trunk* of the tree. Each node *ρ*_{i} has a leaf child *r*_{i}, 1 ≤ *i* ≤ 2*m*, and each node *σ*_{j} and ${\mathit{\sigma}}_{j}^{\prime}$ has a leaf child *s*_{j} and ${s}_{j}^{\prime}$, respectively, 1 ≤ *j* ≤ *n*. Finally, each node *τ*_{h,j}, which corresponds the* h*th literal in clause *C*_{j}, has a child that is the root of a *n*^{2}-thorn with end tip *t*_{h,j} (henceforth referred to as *the*
*n*^{2}
*-thorn for*
*τ*_{h,j}), 1 ≤ *h* ≤ 3, 1 ≤ *j* ≤ *n*. Node *τ*_{3,n} has an additional leaf child so that the tree is binary.

The leaf map *Le* is defined as follows:

- $Le({y}_{i})=Le({\overline{y}}_{i})={r}_{2i-1}$ and $Le({y}_{i}^{\prime})=Le({\overline{y}}_{i}^{\prime})={r}_{2i}$, 1 ≤
*i*≤*m*; *L**e*(*k*_{1,j}) =*L**e*(*k*_{2,j}) =*L**e*(*k*_{3,j}) =*s*_{j}and $Le({k}_{1,j}^{\prime})=Le({k}_{2,j}^{\prime})=Le({k}_{3,j}^{\prime})={s}_{j}^{\prime}$, 1 ≤*j*≤*n*;- Each leaf in the (3
*n*-*m*+ 1)-thorn gadget rooted at node*g*_{1}is mapped to*r*_{0}; - If the
*h*th literal of*C*_{j}is*x*_{i}and this is the*q*th occurrence of*x*_{i}in the 3SAT instance, then each leaf of the (*n*^{2}- 1)-thorn gadget for the*q*th occurrence of*x*_{i}is mapped to the leaf with the same index in the*n*^{2}-thorn gadget for*τ*_{h,j}and ${k}_{h,j}^{\prime \prime}$ is mapped to the end tip,*t*_{h,j}, of that*n*^{2}-thorn gadget. - If the
*h*th literal of*C*_{j}is ${\overline{x}}_{i}$ and this is the*q*th occurrence of ${\overline{x}}_{i}$ in the 3SAT instance, then each leaf of the (*n*^{2}- 1)-thorn gadget for the*q*th occurrence of ${\overline{x}}_{i}$ is mapped to the leaf with the same index in the*n*^{2}-thorn gadget for*τ*_{h,j}and ${k}_{h,j}^{\prime \prime}$ is mapped to the end tip,*t*_{h,j}, of that*n*^{2}-thorn gadget.

Let the event costs be as follows: *D* = 2*B**n*^{2}, *L* = 1, *C* = 0. Finally, note that this reduction can be performed in polynomial time.

To prove the correctness of our reduction, we show that:

- If the max3sat(b) instance is satisfiable, the optimal cost of the constructed DLC instance is less than
*b*= (10*B*+ 2)*n*^{3}+ 121*n*^{2} - For sufficiently large
*n*, if at most (1 -*ϵ*)*n*clauses of the max3sat(b) instance can be satisfied, the optimal cost is more than (1 +*α*)*b*, where$$\begin{array}{c}\hfill \mathit{\alpha}=\frac{\mathit{\u03f5}}{20B+4}\end{array}$$

We first consider a satisfiable instance of max3sat(b). We show how a satisfying valuation can be used to construct a solution to the DLC instance whose cost is less than *b*.

The species map ℳ maps all internal nodes of *G* to *ρ*_{0} except for *g*_{1} and its descendant (3*n* - *m* + 1)-thorn gadget which are mapped to *r*_{0}; each leaf *g* ∈ *L*(*G*) is mapped to *L**e*(*g*).

For each variable *x*_{i}, we place one duplication in the corresponding variable gadget, on the edge $e({\overline{\mathit{\beta}}}_{i})$ if *x*_{i} is assigned true and on the edge *e*(*β*_{i}) if *x*_{i} is assigned false.^{3} This ensures that *y*_{i} and ${\overline{y}}_{i}$ are separated and that ${y}_{i}^{\prime}$ and ${\overline{y}}_{i}^{\prime}$ are separated, as required by part 1 of the leaf map. For each clause *C*_{j}, identify any one literal that satisfies that clause. If the first literal in *C*_{j} satisfies the clause, place duplications on edges *e*(*λ*_{2,j}) and *e*(*λ*_{3,j}). Alternatively, if the second literal in *C*_{j} satisfies the clause, place duplications on edges *e*(*λ*_{1,j}) and *e*(*λ*_{3,j}); alternatively, if the third literal in *C*_{j} satisfies the clause, place duplications on edges *e*(*λ*_{1,j}) and *e*(*λ*_{2,j}). This placement of two duplications per clause gadget satisfies the constraints implied by part 2 of the leaf map, which requires that each pair of *k*_{1,j}, *k*_{2,j}, *k*_{3,j} be separated and that each pair of ${k}_{1,j}^{\prime},{k}_{2,j}^{\prime},{k}_{3,j}^{\prime}$ be separated. Thus far, *m* + 2*n* duplications have been placed. Finally, we place 3*n* - *m* duplications on the terminal edges of the (3*n* - *m* + 1)-thorn gadget, since all 3*n* - *m* + 1 of its leaves are mapped to *r*_{0} by part 3 of the leaf map and thus each pair of leaves must be separated. Note that parts 4 and 5 of the leaf mapping do not map multiple species leaves to the same trees leaves and thus require no additional duplication placements. The total number of duplications is thus *m* + 2*n* + (3*n* - *m*) = 5*n*.

Next, we count the number of losses. We do this by first counting losses on the *n*^{2}-thorns of the species tree and then on the trunk of the species tree.

Each clause *C*_{j} has three *n*^{2}-thorns in the species tree, one branching from each of *τ*_{1,j}, *τ*_{2,j}, and *τ*_{3,j}. Without loss of generality, assume that clause *C*_{j} is satisfied by its first literal and thus duplications were placed on *e*(*λ*_{2,j}) and *e*(*λ*_{3,j}). Also, without loss of generality, assume that the first literal in *C*_{j} is *x*_{i} (the case for ${\overline{x}}_{i}$ is analogous) and that this is the *q*th occurrence of *x*_{i} in the 3SAT instance. The duplication on *e*(*λ*_{2,j}) implies that leaf ${k}_{2,j}^{\prime \prime}$ is mapped to a different locus than all of the leaves of the (*n*^{2} - 1)-thorn for the *q*th occurrence of *x*_{i} in the variable gadget for *x*_{i}. Since $Le({k}_{2,j}^{\prime \prime})={t}_{2,j}$ by part 4 of the leaf map, there is a loss event on each of the *n*^{2} edges terminating at the leaves of the *n*^{2}-thorn gadget for *τ*_{2,j}. Similarly, the duplication on edge *e*(*λ*_{3,j}) incurs *n*^{2} losses in the *n*^{2}-thorn gadget for *τ*_{3,j} for a total of 2*n*^{2} losses for clause *C*_{j}. Since *C*_{j} is satisfied by *x*_{i}, we know that *x*_{i} = true and thus a duplication was placed on edge $e({\overline{\mathit{\beta}}}_{i})$ in the variable gadget for *x*_{i}. Therefore, there is no duplication placed between ${k}_{1,j}^{\prime \prime}$ and the leaves of the (*n*^{2} - 1)-thorn for the *q*th occurrence of *x*_{i} and thus there are no losses incurred on the *n*^{2}-thorn for *τ*_{1,j}. Since there are *n* clauses and each contributes 2*n*^{2} losses in the corresponding *n*^{2}-thorns, 2*n*^{3} losses are incurred thus far.

We next consider the number of losses incurred on the trunk of the species tree. Since ℳ(*g*_{1}) = *r*_{0}, none of the loci created by the 3*n* - *m* duplications in the 3*n* - *m* + 1-thorn required by part 3 of the leaf map induce loss events. There are 1 + 2*m* + 2*n* + 3*n* nodes on the trunk and at most *m* + 2*n* loci can be lost on each of the two edges emanating from each such node since there only *m* + 2*n* other duplications.

Observing that *m* ≤ 3*n*, the total number of losses can thus be bounded from above by

$$\begin{array}{cc}\hfill 2(m+2n)(1+2m+2n+3n)& \le 2\xb75n\xb712n<121{n}^{2}.\hfill \end{array}$$

Therefore, the total cost of this solution is bounded by

5*n* · 2*B**n*^{2} + (2*n*^{3} + 121*n*^{2}) · 1 = (10*B* + 2)*n*^{3} + 121*n*^{2} = *b*.

To complete the proof, we show that given an instance of max3sat(b) in which the fraction of satisfiable clauses is at most (1-*ϵ*), the optimal cost of the corresponding DLC instance, for sufficiently large *n*, is greater than:

$$\begin{array}{cc}\hfill (1+\mathit{\alpha})b& =\left(1+\frac{\mathit{\u03f5}}{20B+4}\right)\left((10B+2){n}^{3}+121{n}^{2}\right)\hfill \\ \hfill & =(10B+2){n}^{3}+\frac{\mathit{\u03f5}}{20B+4}(10B+2){n}^{3}+\left(1+\frac{\mathit{\u03f5}}{20B+4}\right)121{n}^{2}\hfill \\ \hfill & =(10B+2){n}^{3}+\frac{\mathit{\u03f5}}{2}{n}^{3}+\left(1+\frac{\mathit{\u03f5}}{20B+4}\right)121{n}^{2}\hfill \\ \hfill & =\left(10B+2+\frac{\mathit{\u03f5}}{2}\right){n}^{3}+\left(1+\frac{\mathit{\u03f5}}{20B+4}\right)121{n}^{2}.\hfill \end{array}$$

Part 1 of the leaf map requires at least one duplication placement per variable gadget, part 2 of the leaf map requires at least two duplications per clause gadget, and part 3 of the leaf map requires 3*n* - *m* duplications to be placed in the (3*n* - *m* + 1)-thorn gadget. Therefore, all valid duplication placements for this instance use at least *m* + 2*n* + (3*n* - *m*) = 5*n* duplications. We call a solution that uses exactly 5*n* duplications *well-behaved*.

A *well-behaved* solution must use exactly one duplication in each variable gadget. For each variable gadget for variable *x*_{i}, this duplication must be placed on either the edge *e*(*β*_{i}) or the edge $e({\overline{\mathit{\beta}}}_{i})$ in order to separate both *y*_{i} and ${\overline{y}}_{i}$ and ${y}_{i}^{\prime}$ and ${\overline{{y}^{\prime}}}_{i}$. We interpret a duplication on edge *e*(*β*_{i}) as setting variable *x*_{i} to false and a duplication on edge $e({\overline{\mathit{\beta}}}_{i})$ as setting *x*_{i} to true. Thus, a well-behaved solution to the DLC Optimization Problem has a corresponding valuation of the variables in the 3SAT instance.

We now show that all optimal solutions to the DLC Optimization Problem are necessarily well-behaved. Consider a solution for our constructed DLC instance that is not well-behaved and thus comprises more than 5*n* duplications. A duplication placed outside of a variable, clause, or (3*n* - *m* + 1)-thorn gadget cannot satisfy any of the duplication requirements imposed by the leaf map and thus can be removed, reducing the number of duplications and not increasing the number of losses.

If a variable gadget for *x*_{i} contains more than one duplication, we may replace all duplications in that variable gadget with a single duplication on edge *e*(*β*_{i}) = (*α*_{i}, *β*_{i}), which satisfies the duplication requirements of the leaf map and reduces the number of duplications by at least one. Introducing a new duplication may increase the number of losses. However, since each variable *x*_{i} appears in at most *B* clauses in the max3sat(b) instance, the number of new losses introduced can be at most *B**n*^{2} due to the *B*
*n*^{2}-thorn gadgets where losses are introduced and the *O*(*n*) internal vertices in the trunk of the species tree, which is dominated by *B**n*^{2} for sufficiently large *n*. Thus, the total number of new losses incurred is less than 2*B**n*^{2} for sufficiently large *n* and thus less than the cost of the saved duplication.

Similarly, if a clause gadget for *C*_{j} contains more than two duplications, we can replace it with two duplications on the edges *e*(*λ*_{1,j}) and *e*(*λ*_{2,j}). The saving of one duplication is larger than the cost of the additional losses.

We have established that an optimal solution to the constructed DLC instance is necessarily well-behaved. Next, observe that any species map must map ${\mathit{\lambda}}_{h,j}^{\prime}$, 1 ≤ *h* ≤ 3, 1 ≤ *j* ≤ *n*, to a node *v* on the trunk of the species tree such that *v*≤_{T}*τ*_{h,j} since ${\mathit{\lambda}}_{h,j}^{\prime}$ has children ${k}_{h,j}^{\prime}$ and ${k}_{h,j}^{\prime \prime}$ and $Le({k}_{h,j}^{\prime})={s}_{j}^{\prime}$ while $Le({k}_{h,j}^{\prime \prime})={t}_{h,j}$.

Consider an optimal solution for the DLC instance. Since this solution is well-behaved, it induces a valuation of the Boolean variables as described above. As noted earlier, if clause *C*_{j} is satisfied by this valuation then a total of 2*n*^{2} losses are incurred in two of the three *n*^{2}-thorns *τ*_{1,j}, *τ*_{2,j}, and *τ*_{3,j}. Conversely, if clause *C*_{j} is not satisfied by this valuation then a total of 3*n*^{2} losses are incurred in all three of those *n*^{2}-thorns. To see this, let the *h*th literal, 1 ≤ *h* ≤ 3, of *C*_{j} be *x*_{i} (analogously, ${\overline{x}}_{i}$) and let this be the *q*th occurrence of this literal in the 3SAT instance. Since *C*_{j} is not satisfied *x*_{i} = false [analogously, ${\overline{x}}_{i}=$ false and, therefore, there is a duplication placed on edge *e*(*β*_{i}) (analogously, $e({\overline{\mathit{\beta}}}_{i})$]. It follows that the loci of the leaves of the (*n*^{2} - 1)-thorn for the *q*th occurrence of *x*_{i} are different from the locus of ${k}_{h,j}^{\prime \prime}$, causing *n*^{2} losses in the *n*^{2}-thorn for *τ*_{h,j} since, as noted above, the path from $\mathcal{M}({\mathit{\lambda}}_{h,j}^{\prime})$ to $\mathcal{M}({k}_{h,j}^{\prime \prime})={t}_{h,j}$ passes through every internal node of this thorn gadget. Thus, if *C*_{j} is unsatisfied, its three *n*^{2}-thorns in the species tree contribute 3*n*^{2} losses.

We have shown that every satisfied clause contributes 2*n*^{2} losses and every unsatisfied clause contributes 3*n*^{2} losses. Therefore, if there are fewer than 2*n*^{3} + *ϵ**n*^{3} losses then there must be fewer than *ϵ**n* unsatisfied clauses. Since there are more than *ϵ**n* unsatisfied clauses by assumption, for sufficiently large *n*, the cost of a well-behaved solution, and thus of an optimal solution, is at least:

$$\begin{array}{cc}\hfill 5n(2B{n}^{2})+2{n}^{3}+\mathit{\u03f5}{n}^{3}& =(10B+2+\mathit{\u03f5}){n}^{3}\hfill \\ \hfill & >\left(10B+2+\frac{\mathit{\u03f5}}{2}\right){n}^{3}+\left(1+\frac{\mathit{\u03f5}}{20B+4}\right)121{n}^{2}\hfill \\ \hfill & =(1+\mathit{\alpha})b\hfill \end{array}$$

□

We have shown that the DLC parsimony problem is NP-hard even when only duplications are considered and APX-hard when duplications and losses are considered. These results may help guide the direction of future research on algorithms and heuristics for the DLC parsimony problem. In particular, although the existence of a polynomial-time approximation scheme for the DLC parsimony problem would imply that P = NP, approximation algorithms may exist and would be of significant potential value.

All authors contributed to the development of the results and writing of this paper. All authors read and approved the final manuscript.

The authors wish to thank Yi-Chieh Wu and Mukul Bansal for valuable advice and feedback.

The authors declare that they have no competing interests.

This work was funded by the U.S. National Science Foundation under Grant Number IIS-1419739. Any opinions, findings, and conclusions or recommendations expressed in this material are those of the author(s) and do not necessarily reflect the views of the National Science Foundation.

^{1}Wu et al. include one other relation in the LCT, a partial ordering relation 𝒪 on *V*(*G*). This relation is used solely to define and count the number of so-called *coalescence events*. In this paper, we show that the reconciliation problem is intractable even when the cost of coalescence events is ignored. Therefore, while coalescence events are induced by the LCT, there is no need to explicitly identify these events here and we thus omit the partial ordering relation 𝒪 from the above definition.

^{2}Wu et. al use the names *leaves* and *roots* where we use *bottoms* and *tops*, respectively.

^{3}Note that this is opposite of what was done in the preceeding NP-hardness proof. This switch is necessary as becomes evident in the subsequent proof of correctness.

Daniel Bork, Email: ude.cmh.g@krobd.

Ricson Cheng, Email: ude.umc.werdna@cnoscir.

Jincheng Wang, Email: ude.cmh.g@gnawij.

Jean Sung, Email: ude.cmh.g@gnusj.

Ran Libeskind-Hadas, Email: ude.cmh.sc@sadah.

1. Kingman JFC. The coalescent. Stoch Process Appl. 1982;13(3):235–248. doi: 10.1016/0304-4149(82)90011-4. [Cross Ref]

2. Rasmussen M, Kellis M. Unified modeling of gene duplication, loss, and coalescence using a locus tree. Genome Res. 2011;22:755–765. doi: 10.1101/gr.123901.111. [PubMed] [Cross Ref]

3. Wu Y-C, Rasmussen MD, Bansal MS, Kellis M. Most parsimonious reconciliation in the presence of gene duplication, loss, and deep coalescence using labeled coalescent trees. Genome Res. 2014;24(3):475–486. doi: 10.1101/gr.161968.113. [PubMed] [Cross Ref]

4. C-ălinescu G, Fernandes CG, Reed B. Multicuts in unweighted graphs and digraphs with bounded degree and bounded tree-width. J Algorithm. 2003;48(2):333–359. doi: 10.1016/S0196-6774(03)00073-7. [Cross Ref]

5. Bansal MS, Alm EJ, Kellis M. Efficient algorithms for the reconciliation problem with gene duplication, horizontal transfer and loss. Bioinformatics. 2012;28(12):283–291. doi: 10.1093/bioinformatics/bts225. [PMC free article] [PubMed] [Cross Ref]

6. Ovadia Y, Fielder D, Conow C, Libeskind-Hadas R. The cophylogeny reconstruction problem is NP-complete. J Comput Biol. 2011;18(1):59–65. doi: 10.1089/cmb.2009.0240. [PubMed] [Cross Ref]

7. Tofigh A, Hallett MT, Lagergren J. Simultaneous identification of duplications and lateral gene transfers. IEEE/ACM Trans Comput Biol Bioinform. 2011;8(2):517–535. doi: 10.1109/TCBB.2010.14. [PubMed] [Cross Ref]

8. Garey MR, Johnson DS. Computers and intractability: a guide to the theory of NP-completeness. New York: W. H. Freeman & Co.; 1979.

9. Arora S. Probabilistic checking of proofs and hardness of approximation problems. Ph.D. Thesis, Princeton: Princeton University, Department of Computer Science; 1994

Articles from Algorithms for Molecular Biology : AMB are provided here courtesy of **BioMed Central**

PubMed Central Canada is a service of the Canadian Institutes of Health Research (CIHR) working in partnership with the National Research Council's national science library in cooperation with the National Center for Biotechnology Information at the U.S. National Library of Medicine(NCBI/NLM). It includes content provided to the PubMed Central International archive by participating publishers. |