Consensus properties for the deep coalescence problem and their application for scalable tree search

Background To infer a species phylogeny from unlinked genes, phylogenetic inference methods must confront the biological processes that create incongruence between gene trees and the species phylogeny. Intra-specific gene variation in ancestral species can result in deep coalescence, also known as incomplete lineage sorting, which creates incongruence between gene trees and the species tree. One approach to account for deep coalescence in phylogenetic analyses is the deep coalescence problem, which takes a collection of gene trees and seeks the species tree that implies the fewest deep coalescence events. Although this approach is promising for phylogenetics, the consensus properties of this problem are mostly unknown and analyses of large data sets may be computationally prohibitive. Results We prove that the deep coalescence consensus tree problem satisfies the highly desirable Pareto property for clusters (clades). That is, in all instances, each cluster that is present in all of the input gene trees, called a consensus cluster, will also be found in every optimal solution. Moreover, we introduce a new divide and conquer method for the deep coalescence problem based on the Pareto property. This method refines the strict consensus of the input gene trees, thereby, in practice, often greatly reducing the complexity of the tree search and guaranteeing that the estimated species tree will satisfy the Pareto property. Conclusions Analyses of both simulated and empirical data sets demonstrate that the divide and conquer method can greatly improve upon the speed of heuristics that do not consider the Pareto consensus property, while also guaranteeing that the proposed solution fulfills the Pareto property. The divide and conquer method extends the utility of the deep coalescence problem to data sets with enormous numbers of taxa.


Introduction
The rapidly growing abundance of genomic sequence data has revealed extensive incongruence among gene trees (e.g., [1,2]) that may be caused by processes such as deep coalescence (incomplete lineage sorting), gene duplication and loss, or lateral gene transfer (see [3][4][5]). In these cases, phylogenetic methods must account for and explain the patterns of variation among gene tree topologies, rather than simply assuming the gene tree topology reflects the relationships among species. In particular, there has been much recent interest in phylogenetic methods that account for deep coalescence, which may occur in any sexually reproducing organisms (e.g., [6][7][8]). One such approach is the deep coalescence problem, which, given a collection of gene trees, seeks a species tree that minimizes the number of deep coalescence events [4,9]. Although the deep coalescence problem is NP-hard [10], recent algorithmic advances enable scientists to solve instances with a small number of taxa [11,12] and efficiently compute heuristic solutions for data sets with slightly more species [13]. Still, the heuristics are based on generic local tree search strategies with no performance guarantees, and they cannot handle enormous data sets. In this study, we prove that the deep coalescence problem satisfies the Pareto consensus property. We then describe a new divide and conquer approach, based on the Pareto property, that, in practice, can greatly extend the utility of existing heuristics while guaranteeing that the inferred species tree also has the Pareto property with respect to the input gene trees.

Related work
The deep coalescence problem is an example of a supertree problems, in which input trees with taxonomic overlap are combined to build a species tree that includes all of the taxa found in the input trees (see [14]). In fact, it is among the few supertree methods that use a biologically based optimality criterion. One way of evaluating supertree methods is by characterizing their consensus properties (e.g., [15,16]). The consensus tree problem is the special case of the supertree problem in which all the input trees contain the same taxa. Since all supertree problems generally seek to retain phylogenetic information from the input trees, one of the most desirable consensus properties is the Pareto property. A consensus tree problem satisfies the Pareto property on clusters (or triplets, quartets, etc.) if every cluster (or triplet, quartet, etc.) that is present in every input tree appears in the consensus tree [15][16][17]. Many supertree problems satisfy the Pareto property for clusters in the consensus setting [15,16]. However, this has not been shown for the deep coalescence problem.

Our contributions
We prove that the deep coalescence consensus tree problem satisfies the Pareto property for clusters. This result provides useful guidance for the species tree search. Instead of evaluating all possible species trees, to find the optimal solution we need only to examine trees that satisfy the Pareto property on clusters. These trees will all be refinements of the strict consensus of the gene trees. Furthermore, the Pareto property allow us to show that the problem can be divided into smaller independent subproblems based on the strict consensus tree. We apply this property and describe a new divide and conquer method, and our experiments demonstrate that this method can greatly improve the speed of deep coalescence tree heuristics, potentially enabling efficient and effective estimates from inputs with several thousands of taxa. Future work will exploit the independence of the subproblems and solve these on parallel machines, which should result in even larger and more accurate solutions.

Basic definitions, notations, and preliminaries
In this section we introduce basic definitions and notations and then define preliminaries required for this work. For brevity some proofs are omitted in the text but available in Additional file 1.
A graph G is an ordered pair (V, E) consisting of a non-empty set V of nodes and a set E of edges. We denote the set of nodes and edges of G by V(G) and E (G), respectively. If e = {u, v} is an edge of a graph G, then e is said to be incident with u and v. If v is a node of a graph G, then the degree of v in G is the number of edges in G that are incident with v.
A tree T is a connected graph with no cycles. T is rooted if it has exactly one distinguished node of degree one, called the root, and we denote it by Ro(T). The unique edge incident with Ro(T) is called the root edge.
Let T be a rooted tree. We define ≤ T to be the partial order on V (T) where x ≤ T y if y is a node on the path between Ro(T) and x. If x ≤ T y we call x a descendant of y, and y an ancestor of x. We also define x < T y if x ≤ T y and x ≠ y, in this case we call x a proper descendant of y, and y a proper ancestor of x. The set of minima under ≤ T is denoted by Le(T) and its elements are called leaves. A node is internal if it is not a leaf. The set of all internal nodes of T is denoted by I(T). Further, we will frequently refer to the subset of I(T) whose degree is two, and we denote this by I 2 (T).
Let X ⊆ Le (T) , we write X to denote the leaf complement of X when the tree T is clear from the context, where X = Le (T) \X .
If {x, y} E(T) and x < T y then we call y the parent of x denoted by Pa T (x) and we call x a child of y. The set of all children of y is denoted by Ch T y . If two nodes in T have the same parent, they are called siblings. The least common ancestor (LCA) of a non-empty subset X ⊆ V(T), denoted as lca T (X), is the unique smallest upper bound of X under ≤ T .
If e E(T), we define T/e to be the tree obtained from T by identifying the ends of e and then deleting e. T/e is said to be obtained from T by contracting e. If v is a vertex of T with degree one or two, and e is an edge incident with v, the tree T/e is said to be obtained from T by suppressing v.
Examples of the following definitions are shown in Figure 1. Let X ⊆ V(T), the subtree of T induced by X, denoted T(X), is the minimal connected subtree of T that contains Ro(T) and X. The restricted subtree of T induced by X, denoted as T|X, is the tree obtained from T(X) by suppressing all nodes with degree two. The subtree of T rooted above node v V (T), denoted as T v , is the restricted subtree induced by {u V (T): u ≤ T v}.
T is binary if every node has degree one or three. Throughout this paper, the term tree refers to a rooted binary tree unless otherwise stated. Also, the subscript of a notation may be omitted when it is clear from the context.

Deep coalescence
We define the deep coalescence cost function as demonstrated in Figure 2. Note that our definition of the deep coalescence cost given in Def. 3, is somewhat different, but for our purposes equivalent, to its original definition also termed extra lineage given in [4]. The relationship between both definitions is shown in Additional file 1.
Throughout this section we assume T and S are trees over the same leaf set.
Definition 1 (Path length). Suppose x ≤ T y, the path length from x to y, denoted pl T (x, y), is the number of edges in the path from x to y. Further, let X ⊆ Y ⊆ Le (T) , we extend the path length function by pl T (X,Y) ≜ pl T (lca T (X), lca T (Y)).

Consensus tree
Definition 4 (Consensus tree problem). Let f : T x × T x → R be a cost function where X is a leaf set and T x is the set of all trees over X. A consensus tree problem based on f is defined as follows.
Instance: A tuple of n trees (T 1 ,...,T n ) over X Find: The set of all trees that have the minimum aggregated cost with respect to f. Formally, This set is also called the solutions for the consensus tree instance.
Definition 5 (Deep coalescence consensus tree problem). We define the deep coalescence consensus tree problem to be the consensus tree problem based on the deep coalescence cost function.

Cluster and Pareto
Definition 6 (Cluster). Let T be a tree, the clusters induced by T, denoted, Definition 7 (Pareto on clusters). Let P be a consensus tree problem based on some cost function. We say that P is Pareto on clusters if: for all instances I = (T 1 ,...,T n ) of P, for all solutions S of I, we have ∩ n i=1 C1(T i ) ⊆ C1(S) .

Theorem overview
We wish to show that the deep coalescence consensus tree problem is Pareto on clusters. We describe a high level structure of the proof in this section and provide necessary supporting lemmata in the next section. The proof proceeds by contradiction, assuming that the deep coalescence consensus tree problem is not Pareto on clusters. By Def. 7, the assumption implies that there exists an instance I = (T 1 ,...,T n ), a solution S for I, and a cluster S being a solution for I, implies by Def. 4, that the aggregated deep coales- based on the existence of the cluster X, we edit S and form a new tree R using a tree edit operation which will be introduced in the next section. The properties of this new operation together with the properties of X (proved in the next section), provides the key ingredients to calculate the changes in deep coalescence costs. With some further arithmetics, this allows us to conclude that R in fact has a smaller aggregated deep coalescence cost, i.e.
, hence contradicting the assumption that S is a solution for I.

Supporting lemmata Shallowest regrouping operation
In this section we formally define the new tree edit operation that forms the key part of the theorem. We begin with some useful definitions related to the depth of nodes. An example of this operation is shown in Figure 3.
Definition 9 (Shallowest nodes). Let T be a tree and X ⊆ V(T), the shallowest function, denoted shallowest T (X), is the set of nodes in X which have the minimum depth among all nodes in X. Formally, we define shallowest T (X) ≜ argmin vÎX (dep T (v)). Now we have the necessary mechanics to define the new tree edit operation. In what follows, we assume S to be a tree, ∅ ⊂ X ⊂ Le(S), and S = S(X) .
Definition 10 (Regroup). Let v I 2 (S'). The regrouping operation of S by X on v, denoted Γ(S, X, v), is the tree obtained from S' by 1. (R1) Identify Ro(S|X) and v. In other words we adjoin the root of tree S|X onto the node v.
As Figure 3 shows, the shallowest regrouping operation pulls apart X from S and regroups X back onto each of the shallowest nodes in S.

Counting the number of degree-two nodes
The regrouping operation includes the step of suppressing nodes with degree two. Since this step affects path lengths and ultimately deep coalescence costs, we are required to count carefully the number of degree-two nodes under various conditions. Here we assume that T is a tree and {X, Y} is a bipartition of Le(T). We begin with two observations that assert existence of degreetwo nodes, and assert existence of leaf sets given a degree-two node. Observation 1.
The next Lemma says that if the root of T is the parent of lca(X), then the number of degree-two nodes in T(X) is at least the depth of v, where v is a shallowest degree-two node of T(Y). Lemma 1. If Pa (lca (X)) = Ro (T) and v shallowest (I 2 (T(Y))), then dep(v) ≤ |I 2 (T(X))|.
Proof. Assume the premise. Let n = dep(v), we observe that n ≥ 1 because of the root edge. Figure 4 shows the setup and variable assignments for this proof. Let v = v 1 < ... <v n , and let B, A 1 , ... , A n be the leaf sets of the indicated subtrees. We observe the following: The intermediate tree S = S(X) shows its two shallowest degree-two nodes v 1 and v 2 . R 1 and R 2 are the resulting trees of this operation. • v n = lca(X) because Pa (lca (X)) = Ro(T).
.., A n each contains at least an element of Y. For otherwise, each of v 2 , ...,v n becomes a degree-two node in T(Y), contradicting the assumption that v = v 1 is the shallowest degreetwo node in T(Y).
In order to obtain T(X), we must prune subtrees in A 1 whose leaves are in Y (which could be the entire subtree A 1 ). Thus there must be at least one degree-two node in A 1 (or v 1 if A 1 is pruned). Similarly, for 1 <i ≤ n, either v i has degree two or there exists a degree-two node in A i . Overall T(X) has at least n degree-two nodes, as required. □

Properties of the regrouping operation
We examine some properties of the regrouping operation in this section. In general, these properties show that the path lengths defined by LCA's do not increase under several different assumptions. This preservation of path lengths would later assist in the calculation of deep coalescence costs. Throughout this section, we assume S to be a tree, ∅ ⊂ X ⊂ Le(S), and S = S(X).
Proof. Let S" be the tree obtained from S' by identifying Ro(S|X) and v. In other words, S" is the tree after step (R1) of the regroup operation Γ(S, X, v). We will show that pl S ≥ (A, B) ≥ pl S" (A, B) ≥ pl R (A, B). We begin with the first inequality. First, since A ⊆ X we know that lca S Next, by (R2) R is obtained from S" by suppressing some nodes, therefore a path in S" can only be made shorter in R, hence we have pl S" (A, B) ≥ pl R (A, B).
Finally, combining the above results we have pl S (A, B) ≥ pl R (A, B). □

Main theorem
Theorem 1. Deep coalescence consensus tree problem is Pareto on clusters.
Proof. Assume not for a contradiction, then there exists an instance I = (T 1 ,...,T n ), a solution S for I, and a cluster X ⊆ Le(S) where X ∈ ∩ n i=1 Cl(T i ) but X / ∈ Cl (S) . Since X / ∈ Cl (S) , X must be non-trivial, therefore (S, X) does not contain S and is not empty. Let R ∈ (S, X) . We will show that ( contradicting the assumption that S is a solution for I. Let T = T i where 1 ≤ i ≤ n, we will show that DC(T, S) >DC(T, R). This requires that DC(T, S) -DC(T, R) > 0, in other words Since (1) sums over all edges in T, for convenience we partition the edges of T and compute the differences in path lengths for each partition individually. Figure 5 depicts a running example for T, S, and R where X = {a, b, c}.
We identify some specific nodes in order to partition the edges of T. Let S = S(X), w ∈ I 2 (S ) where R = Γ(S, X, w). Since X / ∈ Cl (S) , S' contains at least two nodes with degree two. Let w' I 2 (S') such that w' ≠ w, then S w' contains some leaf y ∉ X (Observation 2). Let x = lca T (X) and z = lca T (X ∪ {y}), we partition the edges of T into {E 1 , E 2 , E 3 , E 4 } as follows.
We consider (1) for each of the partition separately. For clarity, we define the aggregated cost difference Σ i for partition E i as follows.
Claim 1. Σ 1 ≥ p Proof. First we observe that the difference for each path length in this partition is ≥ 0 (Lemma 4), so we have Σ 1 ≥ 0. Since x' = lca S (X), we only need to consider the subtree S x' in computing the path lengths in this partition. Define U = S x' . In particular, the number of degree two nodes in U(X) gives us a lower bound on the total decreases of path lengths, because these nodes are removed to obtain U|X which is a subtree of R. That is, Σ 1 ≥ |I 2 (U(X))|. Lemma 1 applies to U with bipartition {X, Le(U)\X} and the node w, so we have |I 2 (U(X))| ≥ dep U (w). The depth dep U (w) is with respect to U, and we relate it to a path length in S by taking away the root edge, that is dep U (w) − 1 = pl S (w, x ) . Finally, using the definition of p we obtain Σ 1 ≥ |I 2 The fourth equality holds because w is the shallowest degree-two node in S', so that no edges along the path from w to x' are contracted in R, hence pl R (w, x') = pl S (w, x').
, and B = Le(T b ) . We know that A ⊆ X because otherwise this edge should be in E 1 or E 2 . We consider two cases for B. In any case, we have pl S (A, B) − pl R (A, B) ≥ 0 for each edge {a, b} E 3 . This implies that Σ 3 ≥ 0. Further, since w' I 2 (S') and w' ≠ w, w' does not exist in R. We also know that y< S w < S lca S (X ∪ {y}) by the definitions of w' and y. Therefore there exists an edge {a, b} E 3 such that pl S (A, B) − pl R (A, B) ≥ 1. Hence we have Σ 3 ≥ 1.
Claim 4. Σ 4 ≥ 0 Finally, we have Σ 1 +Σ 2 +Σ 3 +Σ 4 ≥ p + (-p) + 1+ 0 =1 > 0. Hence (2) is satisfied, and so is (1). In sum, we have constructed a tree R and showed that DC(T i , R), which contradicts with the assumption that S is a solution for I, in other words the assumption that S has the minimum aggregated cost with respect to the deep coalescence cost function. □

Algorithm for improving a candidate solution
Algorithm 1 takes a consensus tree problem instance and a candidate solution as inputs. If the candidate solution does not display the consensus clusters, it is transformed into one that includes all of the consensus clusters and has a smaller (more optimal) deep coalescence cost.
Algorithm 1 Deep coalescence consensus clusters builder 1: procedure DCConsensusClustersBuilder (I, T) Input: A consensus tree problem instance I = (T 1 ,..., T n ), a candidate solution T for I Output: T, or an improved solution R that contains all consensus clusters of I 2: R T 3: C Set of all consensus clusters of I 4: for all cluster X C do 5: if R does not contain X then 6: v A node in shallowest (I 2 (R(X))) (shallowest degree-two node of R(X) ) 7: R Γ(R, X, v) (regrouping operation of R by X on v) 8: end if 9: end for 10: return R 11: end procedure The correctness of Algorithm 1 follows from the proof of Theorem 1. We now analyze its time complexity. Let m be the number of taxa present in the input trees.

General method for improving a search algorithm
In this section we extend the result of Theorem 1 and show that the deep coalescence consensus tree problem exhibits optimal substructures based on the strict consensus tree of the problem instance. This leads to another simple and general method that improves an existing search algorithm. Figure 6 depicts a running example for this section. We now begin with some useful definitions.
Definition 12 (Strict consensus tree [18]). Given a tuple of n trees I = (T 1 ,...,T n ), the strict consensus tree of I, denoted StrictCon(I), is the unique tree that contains those clusters common to all the input trees. Formally, StrictCon(I) is a (possibly non-binary) tree S such that Definition 13 (Cut on trees). Let H and T be two trees over the same leaf set, such that H is a non-binary tree and T is a binary tree that refines H. Given an internal node h in H, a cut on T via H and h, denoted First we observe that S must be a refinement of H by Theorem 1, therefore S' is defined. We continue to prove by contradiction, assuming the premise holds but S' is not a solution for the instance Cut H,h (I) . So let R' be a solution for the instance Cut H,h (I), this implies . We now modify S by replacing S' with R' as follows: 1. Remove all edges of S', and remove all nodes of S' excepts the root and the leaves.
Let the resulting tree be R. We will show that R has a lower deep coalescence cost, contradicting the assumption that S is a solution for I.
Let Similar to the proof of Theorem 1, we partition the edges of T into {E under , E out , E in } as follows. 1 Recall that the modification of S into R only involves the subtree S', therefore M T S (v) is unchanged for every v occurs in E under and E out . Hence it suffices to evaluate (3) on E in only. However we have already assumed that therefore (3) holds. Overall we have that R has a lower deep coalescence cost, contradicting the assumption that S is a solution for I. □ Theorem 2 implies that every internal node of the strict consensus tree defines an independent subproblem, and solutions of these subproblems can be combined to give a solution to the original deep coalescence consensus tree problem. This leads to the following general divide and conquer method that improves an existing search algorithm.

Results
We used simulation experiments to (i) test if the solutions obtained from efficient heuristics presented in [13]  display the Pareto property, and (ii) compare the performance of our new divide and conquer approach based on the Pareto property to the generic heuristic in [13].

Experiment results 1
First to examine if subtree pruning and regrafting (SPR) heuristic solutions from [13] display the Pareto property, we generated a series of four 14-taxon trees that share few clusters. To do this, we first generated random 11-taxon trees. Next, we generated random 4-taxon trees containing the species 11-14. We then replaced the one of the leaves in the 11-taxon tree with the random 4-taxon tree. This procedure produces gene trees that share at least a single 4-taxon cluster in common. Although this simulation does not reflect a biological process, it represents extreme cases of error or incongruence among gene trees. In three cases with the 14-taxon gene trees, we found that the SPR heuristic did not return a result that contained the consensus cluster. In these cases, our proof demonstrates that there exists a better solution that also contained the consensus cluster. However, the failure of the SPR heuristic in these cases appears to depend on the starting tree; these data sets did not fail with all starting trees. Thus, the shortcomings of the SPR heuristic may be ameliorated by performing multiple runs from different starting trees.

Experiment results 2
We next evaluated the efficacy and scalability of Method 1 and compared it to the standalone SPR heuristic. We generate sets of gene trees, each with different consensus tree structures (depths and branch factors) as follows. The depth of a tree is the maximum number of edges from the root to a leaf, and the branch factor of a tree is the maximum degree of the nodes. For each depth d and a branch factor b, we first generate a complete b-ary tree of depth d, denoted C d,b . This tree represents the consensus tree. We used depths of 2-5, and branch factors of 3-30. For each C d,b , we then generated 10 sets of 20 random gene trees, such that each gene tree is a binary refinement of C d,b . Each set of input trees was given as input to Method 1, using [13] as the external deep coalescence solver. For comparison, we ran the same data sets using [13] as the standalone deep coalescence solver. We calculated the deep coalescence score for each output species tree, and we report the average score of 10 profiles as the score for each C d,b . We also measured and recorded the average runtime of each run. We terminate the execution of the standalone solver if the runtime exceeds two minutes, and in this case the results are not shown. In general, Figure 7 shows that the scores of the trees were very similar from Method 1 and the standalone SPR heuristic. Thus, Method 1 does not appear to improve the quality of the deep coalescence species trees. However, Method 1 shows extreme improvements in the runtime, especially as the branch factors increase.

Experiment results 3
Finally, we examined the performance of Method 1 and compare it to the standalone SPR heuristic using more biologically plausible coalescence simulations. We followed the general structure the coalescence simulation protocol described by Maddison and Knowles [9]. First, we generated 40 256-taxon species trees based on a Yule pure birth process using the r8s software package [19]. To transform the branch lengths from the Yule simulation to represent generations, we multiplied them all by 1,000,000. Next, we simulated coalescence within each species tree (assuming no migration or hybridization) using Mesquite [20]. All simulations produced a single gene copy from each species. For each species tree, we simulated 20 gene trees assuming a constant population size. The population size effects the number of deep coalescence events, with larger populations leading to more incomplete lineage sorting and consequently less agreement among the gene trees. Thus, to incorporate different levels of incomplete lineage sorting, for 20 of the species trees, we used a constant population size of 10,000, and for 20 we used a constant population size of 100,000. Thus, in total, we produced 40 sets of 20 gene trees, with each set simulated from a different 256-taxon species tree.
For each data set, we performed a phylogenetic analyses using Method 1 and also using only the SPR heuristic from Bansal et al. [13]. In contrast to the simulations in Experiment 1, the standalone SPR heuristic of Bansal et al. [13] always returned species trees with all consensus clusters. Of course, all solutions from Method 1 must display the Pareto property. The deep coalescence reconciliation score for the best trees were similar with both algorithms. When the population size was 10,000, the average coalescence cost was 279, and all the gene trees shared an average of 29.4 clusters. In 19 out of the 20 of these simulations, both approaches produced the same results, while in one case, Method 1 found a species tree with a one fewer implied deep coalescence event. When the population size was 100,000, the average coalescence cost was 2142, and the all gene trees shared an average of 19.1 clusters. Although the reconciliation cost never differed by more than 15, Method 1 had a better score in 6 replicates, and the standalone SPR had a better score in 11 replicates. All analyses finished within 30 seconds in a laptop PC, but Method 1 was always faster than SPR alone.

Discussion
In addition to offering a biologically informed optimality criterion to resolve incongruence among gene trees, we prove that the deep coalescence problem also is guaranteed to retain the phylogenetic clusters for which all gene trees agree. Since the deep coalescence problem is NP-hard [10], most meaningful instances will require heuristics to estimate a solution. We demonstrate that the Pareto property can be leveraged to vastly improve upon the running time of heuristics. Method 1 represents a new general approach to phylogenetic algorithms. In most cases, heuristics to estimate solutions for phylogenetic inference problems are based on a few generic search strategies such as the local search heuristics based on nearest neighbor interchange (NNI), SPR, or tree bisection and reconnection (TBR) branch swapping. Although these search strategies often appear to perform well, they are not connected to any specific phylogenetic problems or optimality criteria. Ideally, however, efficient and effective heuristics should be tailored to the properties of the phylogenetic problem. In the case of the deep coalescence consensus tree problem, the Pareto property provides an informative guiding constraint for the tree search. Specifically, when considering possible solutions, we need only consider solutions that contain all clusters from the input gene trees, or, in other words, that refine the strict consensus of the input gene trees.
Still, our simulation experiments suggest that, in many cases, the SPR local search heuristic described by Bansal et al. [13] performs well. While we identified cases in which the estimate from the SPR heuristic did not contain the Pareto clusters, in most cases SPR alone found trees as good, or even slightly better, than Method 1. We note that the size of the simulated coalescence data set, 256 taxa, exceeds the size of the largest published analysis of the deep coalescence consensus tree problem and is far beyond the largest instances (8 taxa) from which exact solutions have been calculated [11], and the SPR found good solutions within 30 seconds. Still, running time for the SPR heuristic does not always scale well, and the results of Experiment 2 suggest that it might not be tractable for extremely large data sets. In these cases, in practice Method 1 may vastly improve upon the running time, while guaranteeing a solution with the Pareto property.
Further, Theorem 2 shows that the deep coalescence consensus tree problem exhibits independent optimal substructures. This implies that, once we compute the strict consensus tree of the problem instance, the rest of Method 1 can be directly parallelized, regardless of which external deep coalescence solver is used. In the case where the external solver guarantees exact solutions, our method would also give exact solutions, but can potentially solve instances with a much larger taxa size compared to running the external solver alone.
Although the Pareto property for the deep coalescence consensus tree problem is desirable, and the divide and conquer method is promising for large-scale analyses, there are limitations to their use. First, the Pareto property and Method 1 are limited to the consensus case, or, instances in which all of the input gene trees contain sequences from all of the species. Also, the Pareto property is only useful when all input trees share some clusters in common. If there are no consensus clusters among the input trees, then Method 1 conveys no run-time benefits. While this may seem like an extreme case, it is possible with high levels of incomplete lineage sorting, or, perhaps more likely, much error in the gene tree estimates. Also, as we add more and more gene trees, we would expect more instances of conflict among the gene trees, potentially converging towards the elimination of consensus clusters. Than and Rosenberg [21] recently proved the existence of cases in which the deep coalescence problem is inconsistent, or converges on the wrong species tree estimate with increasing gene tree data. Although inconsistency is concerning, the Pareto property provides some reassurance. Even in a worse case scenario in which the deep coalescence problem is misled, the optimal solutions will still contain all of the agreed upon clades from the gene trees. Perhaps the greatest advantage of the deep coalescence problem, especially compared to likelihood and Bayesian approaches that infer species trees based on coalescence models (e.g., [22][23][24]), is its computational speed and the feasibility of estimating a species tree from largescale genomic data sets representing hundreds or even thousands of taxa [13]. Not only can our method improve the performance of any existing heuristic, the Pareto property describes a limited subset of possible species trees that must contain the optimal solution.

Conclusions
We prove that the deep coalescence consensus tree problem satisfies the Pareto property for clusters and describe an efficient algorithm that, given a candidate solution that does not display the consensus clusters, transforms the solution so that it includes all the consensus clusters and has a lower deep coalescence cost. We extend the result and prove that the problem exhibits optimal substructures based on the strict consensus tree of the input gene trees. Based on this property, we suggest a new, parallelizable tree search method, in which we refine the strict consensus of the input gene trees. In contrast to previously proposed heuristics, this method guarantees that the proposed solution will contain the Pareto clusters. Also, as our experiments demonstrate, this method can greatly improve the speed of deep coalescence tree heuristics, potentially enabling efficient and effective estimates from input with thousands of taxa.

Additional material
Additional file 1: Omitted proofs in the main manuscript.
List of abbreviations used LCA: least common ancestor; SPR: subtree pruning and regrafting; NNI: nearest neighbor interchange; TBR: tree bisection and reconnection